libkmod/libkmod-module.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 <dirent.h>
  23 #include <errno.h>
  24 #include <fnmatch.h>
  25 #include <inttypes.h>
  26 #include <limits.h>
  27 #include <stdarg.h>
  28 #include <stddef.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <sys/mman.h>
  34 #include <sys/stat.h>
  35 #include <sys/syscall.h>
  36 #include <sys/types.h>
  37 #include <sys/wait.h>
  38 #ifdef HAVE_LINUX_MODULE_H
  39 #include <linux/module.h>
  40 #endif
  41
  42 #include <shared/util.h>
  43
  44 #include "libkmod.h"
  45 #include "libkmod-internal.h"
  46
  47 /**
  48  * SECTION:libkmod-module
  49  * @short_description: operate on kernel modules
  50  */
  51
  52 enum kmod_module_builtin {
  53     KMOD_MODULE_BUILTIN_UNKNOWN,
  54     KMOD_MODULE_BUILTIN_NO,
  55     KMOD_MODULE_BUILTIN_YES,
  56 };
  57
  58 /**
  59  * kmod_module:
  60  *
  61  * Opaque object representing a module.
  62  */
  63 struct kmod_module {
  64         struct kmod_ctx *ctx;
  65         char *hashkey;
  66         char *name;
  67         char *path;
  68         struct kmod_list *dep;
  69         char *options;
  70         const char *install_commands;   /* owned by kmod_config */
  71         const char *remove_commands;    /* owned by kmod_config */
  72         char *alias; /* only set if this module was created from an alias */
  73         struct kmod_file *file;
  74         int n_dep;
  75         int refcount;
  76         struct {
  77                 bool dep : 1;
  78                 bool options : 1;
  79                 bool install_commands : 1;
  80                 bool remove_commands : 1;
  81         } init;
  82
  83         /*
  84          * mark if module is builtin, i.e. it's present on modules.builtin
  85          * file. This is set as soon as it is needed or as soon as we know
  86          * about it, i.e. the module was created from builtin lookup.
  87          */
  88         enum kmod_module_builtin builtin;
  89
  90         /*
  91          * private field used by kmod_module_get_probe_list() to detect
  92          * dependency loops
  93          */
  94         bool visited : 1;
  95
  96         /*
  97          * set by kmod_module_get_probe_list: indicates for probe_insert()
  98          * whether the module's command and softdep should be ignored
  99          */
 100         bool ignorecmd : 1;
 101
 102         /*
 103          * set by kmod_module_get_probe_list: indicates whether this is the
 104          * module the user asked for or its dependency, or whether this
 105          * is a softdep only
 106          */
 107         bool required : 1;
 108 };
 109
 110 static inline const char *path_join(const char *path, size_t prefixlen,
 111                                                         char buf[PATH_MAX])
 112 {
 113         size_t pathlen;
 114
 115         if (path[0] == '/')
 116                 return path;
 117
 118         pathlen = strlen(path);
 119         if (prefixlen + pathlen + 1 >= PATH_MAX)
 120                 return NULL;
 121
 122         memcpy(buf + prefixlen, path, pathlen + 1);
 123         return buf;
 124 }
 125
 126 static inline bool module_is_inkernel(struct kmod_module *mod)
 127 {
 128         int state = kmod_module_get_initstate(mod);
 129
 130         if (state == KMOD_MODULE_LIVE ||
 131                         state == KMOD_MODULE_BUILTIN)
 132                 return true;
 133
 134         return false;
 135 }
 136
 137 int kmod_module_parse_depline(struct kmod_module *mod, char *line)
 138 {
 139         struct kmod_ctx *ctx = mod->ctx;
 140         struct kmod_list *list = NULL;
 141         const char *dirname;
 142         char buf[PATH_MAX];
 143         char *p, *saveptr;
 144         int err = 0, n = 0;
 145         size_t dirnamelen;
 146
 147         if (mod->init.dep)
 148                 return mod->n_dep;
 149         assert(mod->dep == NULL);
 150         mod->init.dep = true;
 151
 152         p = strchr(line, ':');
 153         if (p == NULL)
 154                 return 0;
 155
 156         *p = '\0';
 157         dirname = kmod_get_dirname(mod->ctx);
 158         dirnamelen = strlen(dirname);
 159         if (dirnamelen + 2 >= PATH_MAX)
 160                 return 0;
 161
 162         memcpy(buf, dirname, dirnamelen);
 163         buf[dirnamelen] = '/';
 164         dirnamelen++;
 165         buf[dirnamelen] = '\0';
 166
 167         if (mod->path == NULL) {
 168                 const char *str = path_join(line, dirnamelen, buf);
 169                 if (str == NULL)
 170                         return 0;
 171                 mod->path = strdup(str);
 172                 if (mod->path == NULL)
 173                         return 0;
 174         }
 175
 176         p++;
 177         for (p = strtok_r(p, " \t", &saveptr); p != NULL;
 178                                         p = strtok_r(NULL, " \t", &saveptr)) {
 179                 struct kmod_module *depmod = NULL;
 180                 const char *path;
 181
 182                 path = path_join(p, dirnamelen, buf);
 183                 if (path == NULL) {
 184                         ERR(ctx, "could not join path '%s' and '%s'.\n",
 185                             dirname, p);
 186                         goto fail;
 187                 }
 188
 189                 err = kmod_module_new_from_path(ctx, path, &depmod);
 190                 if (err < 0) {
 191                         ERR(ctx, "ctx=%p path=%s error=%s\n",
 192                                                 ctx, path, strerror(-err));
 193                         goto fail;
 194                 }
 195
 196                 DBG(ctx, "add dep: %s\n", path);
 197
 198                 list = kmod_list_prepend(list, depmod);
 199                 n++;
 200         }
 201
 202         DBG(ctx, "%d dependencies for %s\n", n, mod->name);
 203
 204         mod->dep = list;
 205         mod->n_dep = n;
 206         return n;
 207
 208 fail:
 209         kmod_module_unref_list(list);
 210         mod->init.dep = false;
 211         return err;
 212 }
 213
 214 void kmod_module_set_visited(struct kmod_module *mod, bool visited)
 215 {
 216         mod->visited = visited;
 217 }
 218
 219 void kmod_module_set_builtin(struct kmod_module *mod, bool builtin)
 220 {
 221         mod->builtin =
 222                 builtin ? KMOD_MODULE_BUILTIN_YES : KMOD_MODULE_BUILTIN_NO;
 223 }
 224
 225 void kmod_module_set_required(struct kmod_module *mod, bool required)
 226 {
 227         mod->required = required;
 228 }
 229
 230 bool kmod_module_is_builtin(struct kmod_module *mod)
 231 {
 232         if (mod->builtin == KMOD_MODULE_BUILTIN_UNKNOWN) {
 233                 kmod_module_set_builtin(mod,
 234                                         kmod_lookup_alias_is_builtin(mod->ctx, mod->name));
 235         }
 236
 237         return mod->builtin == KMOD_MODULE_BUILTIN_YES;
 238 }
 239 /*
 240  * Memory layout with alias:
 241  *
 242  * struct kmod_module {
 243  *        hashkey -----.
 244  *        alias -----. |
 245  *        name ----. | |
 246  * }               | | |
 247  * name <----------' | |
 248  * alias <-----------' |
 249  * name\alias <--------'
 250  *
 251  * Memory layout without alias:
 252  *
 253  * struct kmod_module {
 254  *        hashkey ---.
 255  *        alias -----|----> NULL
 256  *        name ----. |
 257  * }               | |
 258  * name <----------'-'
 259  *
 260  * @key is "name\alias" or "name" (in which case alias == NULL)
 261  */
 262 static int kmod_module_new(struct kmod_ctx *ctx, const char *key,
 263                                 const char *name, size_t namelen,
 264                                 const char *alias, size_t aliaslen,
 265                                 struct kmod_module **mod)
 266 {
 267         struct kmod_module *m;
 268         size_t keylen;
 269
 270         m = kmod_pool_get_module(ctx, key);
 271         if (m != NULL) {
 272                 *mod = kmod_module_ref(m);
 273                 return 0;
 274         }
 275
 276         if (alias == NULL)
 277                 keylen = namelen;
 278         else
 279                 keylen = namelen + aliaslen + 1;
 280
 281         m = malloc(sizeof(*m) + (alias == NULL ? 1 : 2) * (keylen + 1));
 282         if (m == NULL)
 283                 return -ENOMEM;
 284
 285         memset(m, 0, sizeof(*m));
 286
 287         m->ctx = kmod_ref(ctx);
 288         m->name = (char *)m + sizeof(*m);
 289         memcpy(m->name, key, keylen + 1);
 290         if (alias == NULL) {
 291                 m->hashkey = m->name;
 292                 m->alias = NULL;
 293         } else {
 294                 m->name[namelen] = '\0';
 295                 m->alias = m->name + namelen + 1;
 296                 m->hashkey = m->name + keylen + 1;
 297                 memcpy(m->hashkey, key, keylen + 1);
 298         }
 299
 300         m->refcount = 1;
 301         kmod_pool_add_module(ctx, m, m->hashkey);
 302         *mod = m;
 303
 304         return 0;
 305 }
 306
 307 /**
 308  * kmod_module_new_from_name:
 309  * @ctx: kmod library context
 310  * @name: name of the module
 311  * @mod: where to save the created struct kmod_module
 312  *
 313  * Create a new struct kmod_module using the module name. @name can not be an
 314  * alias, file name or anything else; it must be a module name. There's no
 315  * check if the module exists in the system.
 316  *
 317  * This function is also used internally by many others that return a new
 318  * struct kmod_module or a new list of modules.
 319  *
 320  * The initial refcount is 1, and needs to be decremented to release the
 321  * resources of the kmod_module. Since libkmod keeps track of all
 322  * kmod_modules created, they are all released upon @ctx destruction too. Do
 323  * not unref @ctx before all the desired operations with the returned
 324  * kmod_module are done.
 325  *
 326  * Returns: 0 on success or < 0 otherwise. It fails if name is not a valid
 327  * module name or if memory allocation failed.
 328  */
 329 KMOD_EXPORT int kmod_module_new_from_name(struct kmod_ctx *ctx,
 330                                                 const char *name,
 331                                                 struct kmod_module **mod)
 332 {
 333         size_t namelen;
 334         char name_norm[PATH_MAX];
 335
 336         if (ctx == NULL || name == NULL || mod == NULL)
 337                 return -ENOENT;
 338
 339         modname_normalize(name, name_norm, &namelen);
 340
 341         return kmod_module_new(ctx, name_norm, name_norm, namelen, NULL, 0, mod);
 342 }
 343
 344 int kmod_module_new_from_alias(struct kmod_ctx *ctx, const char *alias,
 345                                 const char *name, struct kmod_module **mod)
 346 {
 347         int err;
 348         char key[PATH_MAX];
 349         size_t namelen = strlen(name);
 350         size_t aliaslen = strlen(alias);
 351
 352         if (namelen + aliaslen + 2 > PATH_MAX)
 353                 return -ENAMETOOLONG;
 354
 355         memcpy(key, name, namelen);
 356         memcpy(key + namelen + 1, alias, aliaslen + 1);
 357         key[namelen] = '\\';
 358
 359         err = kmod_module_new(ctx, key, name, namelen, alias, aliaslen, mod);
 360         if (err < 0)
 361                 return err;
 362
 363         return 0;
 364 }
 365
 366 /**
 367  * kmod_module_new_from_path:
 368  * @ctx: kmod library context
 369  * @path: path where to find the given module
 370  * @mod: where to save the created struct kmod_module
 371  *
 372  * Create a new struct kmod_module using the module path. @path must be an
 373  * existent file with in the filesystem and must be accessible to libkmod.
 374  *
 375  * The initial refcount is 1, and needs to be decremented to release the
 376  * resources of the kmod_module. Since libkmod keeps track of all
 377  * kmod_modules created, they are all released upon @ctx destruction too. Do
 378  * not unref @ctx before all the desired operations with the returned
 379  * kmod_module are done.
 380  *
 381  * If @path is relative, it's treated as relative to the current working
 382  * directory. Otherwise, give an absolute path.
 383  *
 384  * Returns: 0 on success or < 0 otherwise. It fails if file does not exist, if
 385  * it's not a valid file for a kmod_module or if memory allocation failed.
 386  */
 387 KMOD_EXPORT int kmod_module_new_from_path(struct kmod_ctx *ctx,
 388                                                 const char *path,
 389                                                 struct kmod_module **mod)
 390 {
 391         struct kmod_module *m;
 392         int err;
 393         struct stat st;
 394         char name[PATH_MAX];
 395         char *abspath;
 396         size_t namelen;
 397
 398         if (ctx == NULL || path == NULL || mod == NULL)
 399                 return -ENOENT;
 400
 401         abspath = path_make_absolute_cwd(path);
 402         if (abspath == NULL) {
 403                 DBG(ctx, "no absolute path for %s\n", path);
 404                 return -ENOMEM;
 405         }
 406
 407         err = stat(abspath, &st);
 408         if (err < 0) {
 409                 err = -errno;
 410                 DBG(ctx, "stat %s: %s\n", path, strerror(errno));
 411                 free(abspath);
 412                 return err;
 413         }
 414
 415         if (path_to_modname(path, name, &namelen) == NULL) {
 416                 DBG(ctx, "could not get modname from path %s\n", path);
 417                 free(abspath);
 418                 return -ENOENT;
 419         }
 420
 421         m = kmod_pool_get_module(ctx, name);
 422         if (m != NULL) {
 423                 if (m->path == NULL)
 424                         m->path = abspath;
 425                 else if (streq(m->path, abspath))
 426                         free(abspath);
 427                 else {
 428                         ERR(ctx, "kmod_module '%s' already exists with different path: new-path='%s' old-path='%s'\n",
 429                                                         name, abspath, m->path);
 430                         free(abspath);
 431                         return -EEXIST;
 432                 }
 433
 434                 *mod = kmod_module_ref(m);
 435                 return 0;
 436         }
 437
 438         err = kmod_module_new(ctx, name, name, namelen, NULL, 0, &m);
 439         if (err < 0) {
 440                 free(abspath);
 441                 return err;
 442         }
 443
 444         m->path = abspath;
 445         *mod = m;
 446
 447         return 0;
 448 }
 449
 450 /**
 451  * kmod_module_unref:
 452  * @mod: kmod module
 453  *
 454  * Drop a reference of the kmod module. If the refcount reaches zero, its
 455  * resources are released.
 456  *
 457  * Returns: NULL if @mod is NULL or if the module was released. Otherwise it
 458  * returns the passed @mod with its refcount decremented.
 459  */
 460 KMOD_EXPORT struct kmod_module *kmod_module_unref(struct kmod_module *mod)
 461 {
 462         if (mod == NULL)
 463                 return NULL;
 464
 465         if (--mod->refcount > 0)
 466                 return mod;
 467
 468         DBG(mod->ctx, "kmod_module %p released\n", mod);
 469
 470         kmod_pool_del_module(mod->ctx, mod, mod->hashkey);
 471         kmod_module_unref_list(mod->dep);
 472
 473         if (mod->file)
 474                 kmod_file_unref(mod->file);
 475
 476         kmod_unref(mod->ctx);
 477         free(mod->options);
 478         free(mod->path);
 479         free(mod);
 480         return NULL;
 481 }
 482
 483 /**
 484  * kmod_module_ref:
 485  * @mod: kmod module
 486  *
 487  * Take a reference of the kmod module, incrementing its refcount.
 488  *
 489  * Returns: the passed @module with its refcount incremented.
 490  */
 491 KMOD_EXPORT struct kmod_module *kmod_module_ref(struct kmod_module *mod)
 492 {
 493         if (mod == NULL)
 494                 return NULL;
 495
 496         mod->refcount++;
 497
 498         return mod;
 499 }
 500
 501 #define CHECK_ERR_AND_FINISH(_err, _label_err, _list, label_finish)     \
 502         do {                                                            \
 503                 if ((_err) < 0)                                         \
 504                         goto _label_err;                                \
 505                 if (*(_list) != NULL)                                   \
 506                         goto finish;                                    \
 507         } while (0)
 508
 509 /**
 510  * kmod_module_new_from_lookup:
 511  * @ctx: kmod library context
 512  * @given_alias: alias to look for
 513  * @list: an empty list where to save the list of modules matching
 514  * @given_alias
 515  *
 516  * Create a new list of kmod modules using an alias or module name and lookup
 517  * libkmod's configuration files and indexes in order to find the module.
 518  * Once it's found in one of the places, it stops searching and create the
 519  * list of modules that is saved in @list.
 520  *
 521  * The search order is: 1. aliases in configuration file; 2. module names in
 522  * modules.dep index; 3. symbol aliases in modules.symbols index; 4. aliases
 523  * in modules.alias index.
 524  *
 525  * The initial refcount is 1, and needs to be decremented to release the
 526  * resources of the kmod_module. The returned @list must be released by
 527  * calling kmod_module_unref_list(). Since libkmod keeps track of all
 528  * kmod_modules created, they are all released upon @ctx destruction too. Do
 529  * not unref @ctx before all the desired operations with the returned list are
 530  * completed.
 531  *
 532  * Returns: 0 on success or < 0 otherwise. It fails if any of the lookup
 533  * methods failed, which is basically due to memory allocation fail. If module
 534  * is not found, it still returns 0, but @list is an empty list.
 535  */
 536 KMOD_EXPORT int kmod_module_new_from_lookup(struct kmod_ctx *ctx,
 537                                                 const char *given_alias,
 538                                                 struct kmod_list **list)
 539 {
 540         int err;
 541         char alias[PATH_MAX];
 542
 543         if (ctx == NULL || given_alias == NULL)
 544                 return -ENOENT;
 545
 546         if (list == NULL || *list != NULL) {
 547                 ERR(ctx, "An empty list is needed to create lookup\n");
 548                 return -ENOSYS;
 549         }
 550
 551         if (alias_normalize(given_alias, alias, NULL) < 0) {
 552                 DBG(ctx, "invalid alias: %s\n", given_alias);
 553                 return -EINVAL;
 554         }
 555
 556         DBG(ctx, "input alias=%s, normalized=%s\n", given_alias, alias);
 557
 558         /* Aliases from config file override all the others */
 559         err = kmod_lookup_alias_from_config(ctx, alias, list);
 560         CHECK_ERR_AND_FINISH(err, fail, list, finish);
 561
 562         DBG(ctx, "lookup modules.dep %s\n", alias);
 563         err = kmod_lookup_alias_from_moddep_file(ctx, alias, list);
 564         CHECK_ERR_AND_FINISH(err, fail, list, finish);
 565
 566         DBG(ctx, "lookup modules.symbols %s\n", alias);
 567         err = kmod_lookup_alias_from_symbols_file(ctx, alias, list);
 568         CHECK_ERR_AND_FINISH(err, fail, list, finish);
 569
 570         DBG(ctx, "lookup install and remove commands %s\n", alias);
 571         err = kmod_lookup_alias_from_commands(ctx, alias, list);
 572         CHECK_ERR_AND_FINISH(err, fail, list, finish);
 573
 574         DBG(ctx, "lookup modules.aliases %s\n", alias);
 575         err = kmod_lookup_alias_from_aliases_file(ctx, alias, list);
 576         CHECK_ERR_AND_FINISH(err, fail, list, finish);
 577
 578         DBG(ctx, "lookup modules.builtin %s\n", alias);
 579         err = kmod_lookup_alias_from_builtin_file(ctx, alias, list);
 580         CHECK_ERR_AND_FINISH(err, fail, list, finish);
 581
 582 finish:
 583         DBG(ctx, "lookup %s=%d, list=%p\n", alias, err, *list);
 584         return err;
 585 fail:
 586         DBG(ctx, "Failed to lookup %s\n", alias);
 587         kmod_module_unref_list(*list);
 588         *list = NULL;
 589         return err;
 590 }
 591 #undef CHECK_ERR_AND_FINISH
 592
 593 /**
 594  * kmod_module_unref_list:
 595  * @list: list of kmod modules
 596  *
 597  * Drop a reference of each kmod module in @list and releases the resources
 598  * taken by the list itself.
 599  *
 600  * Returns: 0
 601  */
 602 KMOD_EXPORT int kmod_module_unref_list(struct kmod_list *list)
 603 {
 604         for (; list != NULL; list = kmod_list_remove(list))
 605                 kmod_module_unref(list->data);
 606
 607         return 0;
 608 }
 609
 610 /**
 611  * kmod_module_get_filtered_blacklist:
 612  * @ctx: kmod library context
 613  * @input: list of kmod_module to be filtered with blacklist
 614  * @output: where to save the new list
 615  *
 616  * This function should not be used. Use kmod_module_apply_filter instead.
 617  *
 618  * Given a list @input, this function filter it out with config's blacklist
 619  * and save it in @output.
 620  *
 621  * Returns: 0 on success or < 0 otherwise. @output is saved with the updated
 622  * list.
 623  */
 624 KMOD_EXPORT int kmod_module_get_filtered_blacklist(const struct kmod_ctx *ctx,
 625                                                 const struct kmod_list *input,
 626                                                 struct kmod_list **output)
 627 {
 628         return kmod_module_apply_filter(ctx, KMOD_FILTER_BLACKLIST, input, output);
 629 }
 630
 631 static const struct kmod_list *module_get_dependencies_noref(const struct kmod_module *mod)
 632 {
 633         if (!mod->init.dep) {
 634                 /* lazy init */
 635                 char *line = kmod_search_moddep(mod->ctx, mod->name);
 636
 637                 if (line == NULL)
 638                         return NULL;
 639
 640                 kmod_module_parse_depline((struct kmod_module *)mod, line);
 641                 free(line);
 642
 643                 if (!mod->init.dep)
 644                         return NULL;
 645         }
 646
 647         return mod->dep;
 648 }
 649
 650 /**
 651  * kmod_module_get_dependencies:
 652  * @mod: kmod module
 653  *
 654  * Search the modules.dep index to find the dependencies of the given @mod.
 655  * The result is cached in @mod, so subsequent calls to this function will
 656  * return the already searched list of modules.
 657  *
 658  * Returns: NULL on failure. Otherwise it returns a list of kmod modules
 659  * that can be released by calling kmod_module_unref_list().
 660  */
 661 KMOD_EXPORT struct kmod_list *kmod_module_get_dependencies(const struct kmod_module *mod)
 662 {
 663         struct kmod_list *l, *l_new, *list_new = NULL;
 664
 665         if (mod == NULL)
 666                 return NULL;
 667
 668         module_get_dependencies_noref(mod);
 669
 670         kmod_list_foreach(l, mod->dep) {
 671                 l_new = kmod_list_append(list_new, kmod_module_ref(l->data));
 672                 if (l_new == NULL) {
 673                         kmod_module_unref(l->data);
 674                         goto fail;
 675                 }
 676
 677                 list_new = l_new;
 678         }
 679
 680         return list_new;
 681
 682 fail:
 683         ERR(mod->ctx, "out of memory\n");
 684         kmod_module_unref_list(list_new);
 685         return NULL;
 686 }
 687
 688 /**
 689  * kmod_module_get_module:
 690  * @entry: an entry in a list of kmod modules.
 691  *
 692  * Get the kmod module of this @entry in the list, increasing its refcount.
 693  * After it's used, unref it. Since the refcount is incremented upon return,
 694  * you still have to call kmod_module_unref_list() to release the list of kmod
 695  * modules.
 696  *
 697  * Returns: NULL on failure or the kmod_module contained in this list entry
 698  * with its refcount incremented.
 699  */
 700 KMOD_EXPORT struct kmod_module *kmod_module_get_module(const struct kmod_list *entry)
 701 {
 702         if (entry == NULL)
 703                 return NULL;
 704
 705         return kmod_module_ref(entry->data);
 706 }
 707
 708 /**
 709  * kmod_module_get_name:
 710  * @mod: kmod module
 711  *
 712  * Get the name of this kmod module. Name is always available, independently
 713  * if it was created by kmod_module_new_from_name() or another function and
 714  * it's always normalized (dashes are replaced with underscores).
 715  *
 716  * Returns: the name of this kmod module.
 717  */
 718 KMOD_EXPORT const char *kmod_module_get_name(const struct kmod_module *mod)
 719 {
 720         if (mod == NULL)
 721                 return NULL;
 722
 723         return mod->name;
 724 }
 725
 726 /**
 727  * kmod_module_get_path:
 728  * @mod: kmod module
 729  *
 730  * Get the path of this kmod module. If this kmod module was not created by
 731  * path, it can search the modules.dep index in order to find out the module
 732  * under context's dirname.
 733  *
 734  * Returns: the path of this kmod module or NULL if such information is not
 735  * available.
 736  */
 737 KMOD_EXPORT const char *kmod_module_get_path(const struct kmod_module *mod)
 738 {
 739         char *line;
 740
 741         if (mod == NULL)
 742                 return NULL;
 743
 744         DBG(mod->ctx, "name='%s' path='%s'\n", mod->name, mod->path);
 745
 746         if (mod->path != NULL)
 747                 return mod->path;
 748         if (mod->init.dep)
 749                 return NULL;
 750
 751         /* lazy init */
 752         line = kmod_search_moddep(mod->ctx, mod->name);
 753         if (line == NULL)
 754                 return NULL;
 755
 756         kmod_module_parse_depline((struct kmod_module *) mod, line);
 757         free(line);
 758
 759         return mod->path;
 760 }
 761
 762
 763 extern long delete_module(const char *name, unsigned int flags);
 764
 765 /**
 766  * kmod_module_remove_module:
 767  * @mod: kmod module
 768  * @flags: flags to pass to Linux kernel when removing the module. The only valid flag is
 769  * KMOD_REMOVE_FORCE: force remove module regardless if it's still in
 770  * use by a kernel subsystem or other process;
 771  * KMOD_REMOVE_NOWAIT is always enforced, causing us to pass O_NONBLOCK to
 772  * delete_module(2).
 773  *
 774  * Remove a module from Linux kernel.
 775  *
 776  * Returns: 0 on success or < 0 on failure.
 777  */
 778 KMOD_EXPORT int kmod_module_remove_module(struct kmod_module *mod,
 779                                                         unsigned int flags)
 780 {
 781         int err;
 782
 783         if (mod == NULL)
 784                 return -ENOENT;
 785
 786         /* Filter out other flags and force ONONBLOCK */
 787         flags &= KMOD_REMOVE_FORCE;
 788         flags |= KMOD_REMOVE_NOWAIT;
 789
 790         err = delete_module(mod->name, flags);
 791         if (err != 0) {
 792                 err = -errno;
 793                 ERR(mod->ctx, "could not remove '%s': %m\n", mod->name);
 794         }
 795
 796         return err;
 797 }
 798
 799 extern long init_module(const void *mem, unsigned long len, const char *args);
 800
 801 /**
 802  * kmod_module_insert_module:
 803  * @mod: kmod module
 804  * @flags: flags are not passed to Linux Kernel, but instead they dictate the
 805  * behavior of this function, valid flags are
 806  * KMOD_INSERT_FORCE_VERMAGIC: ignore kernel version magic;
 807  * KMOD_INSERT_FORCE_MODVERSION: ignore symbol version hashes.
 808  * @options: module's options to pass to Linux Kernel.
 809  *
 810  * Insert a module in Linux kernel. It opens the file pointed by @mod,
 811  * mmap'ing it and passing to kernel.
 812  *
 813  * Returns: 0 on success or < 0 on failure. If module is already loaded it
 814  * returns -EEXIST.
 815  */
 816 KMOD_EXPORT int kmod_module_insert_module(struct kmod_module *mod,
 817                                                         unsigned int flags,
 818                                                         const char *options)
 819 {
 820         int err;
 821         const void *mem;
 822         off_t size;
 823         struct kmod_elf *elf;
 824         const char *path;
 825         const char *args = options ? options : "";
 826
 827         if (mod == NULL)
 828                 return -ENOENT;
 829
 830         path = kmod_module_get_path(mod);
 831         if (path == NULL) {
 832                 ERR(mod->ctx, "could not find module by name='%s'\n", mod->name);
 833                 return -ENOENT;
 834         }
 835
 836         if (!mod->file) {
 837                 mod->file = kmod_file_open(mod->ctx, path);
 838                 if (mod->file == NULL) {
 839                         err = -errno;
 840                         return err;
 841                 }
 842         }
 843
 844         if (kmod_file_get_direct(mod->file)) {
 845                 unsigned int kernel_flags = 0;
 846
 847                 if (flags & KMOD_INSERT_FORCE_VERMAGIC)
 848                         kernel_flags |= MODULE_INIT_IGNORE_VERMAGIC;
 849                 if (flags & KMOD_INSERT_FORCE_MODVERSION)
 850                         kernel_flags |= MODULE_INIT_IGNORE_MODVERSIONS;
 851
 852                 err = finit_module(kmod_file_get_fd(mod->file), args, kernel_flags);
 853                 if (err == 0 || errno != ENOSYS)
 854                         goto init_finished;
 855         }
 856
 857         if (flags & (KMOD_INSERT_FORCE_VERMAGIC | KMOD_INSERT_FORCE_MODVERSION)) {
 858                 elf = kmod_file_get_elf(mod->file);
 859                 if (elf == NULL) {
 860                         err = -errno;
 861                         return err;
 862                 }
 863
 864                 if (flags & KMOD_INSERT_FORCE_MODVERSION) {
 865                         err = kmod_elf_strip_section(elf, "__versions");
 866                         if (err < 0)
 867                                 INFO(mod->ctx, "Failed to strip modversion: %s\n", strerror(-err));
 868                 }
 869
 870                 if (flags & KMOD_INSERT_FORCE_VERMAGIC) {
 871                         err = kmod_elf_strip_vermagic(elf);
 872                         if (err < 0)
 873                                 INFO(mod->ctx, "Failed to strip vermagic: %s\n", strerror(-err));
 874                 }
 875
 876                 mem = kmod_elf_get_memory(elf);
 877         } else {
 878                 mem = kmod_file_get_contents(mod->file);
 879         }
 880         size = kmod_file_get_size(mod->file);
 881
 882         err = init_module(mem, size, args);
 883 init_finished:
 884         if (err < 0) {
 885                 err = -errno;
 886                 INFO(mod->ctx, "Failed to insert module '%s': %m\n", path);
 887         }
 888         return err;
 889 }
 890
 891 static bool module_is_blacklisted(struct kmod_module *mod)
 892 {
 893         struct kmod_ctx *ctx = mod->ctx;
 894         const struct kmod_config *config = kmod_get_config(ctx);
 895         const struct kmod_list *bl = config->blacklists;
 896         const struct kmod_list *l;
 897
 898         kmod_list_foreach(l, bl) {
 899                 const char *modname = kmod_blacklist_get_modname(l);
 900
 901                 if (streq(modname, mod->name))
 902                         return true;
 903         }
 904
 905         return false;
 906 }
 907
 908 /**
 909  * kmod_module_apply_filter
 910  * @ctx: kmod library context
 911  * @filter_type: bitmask to filter modules out, valid types are
 912  * KMOD_FILTER_BLACKLIST: filter modules in blacklist out;
 913  * KMOD_FILTER_BUILTIN: filter builtin modules out.
 914  * @input: list of kmod_module to be filtered
 915  * @output: where to save the new list
 916  *
 917  * Given a list @input, this function filter it out by the filter mask
 918  * and save it in @output.
 919  *
 920  * Returns: 0 on success or < 0 otherwise. @output is saved with the updated
 921  * list.
 922  */
 923 KMOD_EXPORT int kmod_module_apply_filter(const struct kmod_ctx *ctx,
 924                                                 enum kmod_filter filter_type,
 925                                                 const struct kmod_list *input,
 926                                                 struct kmod_list **output)
 927 {
 928         const struct kmod_list *li;
 929
 930         if (ctx == NULL || output == NULL)
 931                 return -ENOENT;
 932
 933         *output = NULL;
 934         if (input == NULL)
 935                 return 0;
 936
 937         kmod_list_foreach(li, input) {
 938                 struct kmod_module *mod = li->data;
 939                 struct kmod_list *node;
 940
 941                 if ((filter_type & KMOD_FILTER_BLACKLIST) &&
 942                                 module_is_blacklisted(mod))
 943                         continue;
 944
 945                 if ((filter_type & KMOD_FILTER_BUILTIN)
 946                     && kmod_module_is_builtin(mod))
 947                         continue;
 948
 949                 node = kmod_list_append(*output, mod);
 950                 if (node == NULL)
 951                         goto fail;
 952
 953                 *output = node;
 954                 kmod_module_ref(mod);
 955         }
 956
 957         return 0;
 958
 959 fail:
 960         kmod_module_unref_list(*output);
 961         *output = NULL;
 962         return -ENOMEM;
 963 }
 964
 965 static int command_do(struct kmod_module *mod, const char *type,
 966                                                         const char *cmd)
 967 {
 968         const char *modname = kmod_module_get_name(mod);
 969         int err;
 970
 971         DBG(mod->ctx, "%s %s\n", type, cmd);
 972
 973         setenv("MODPROBE_MODULE", modname, 1);
 974         err = system(cmd);
 975         unsetenv("MODPROBE_MODULE");
 976
 977         if (err == -1 || WEXITSTATUS(err)) {
 978                 ERR(mod->ctx, "Error running %s command for %s\n",
 979                                                                 type, modname);
 980                 if (err != -1)
 981                         err = -WEXITSTATUS(err);
 982         }
 983
 984         return err;
 985 }
 986
 987 struct probe_insert_cb {
 988         int (*run_install)(struct kmod_module *m, const char *cmd, void *data);
 989         void *data;
 990 };
 991
 992 static int module_do_install_commands(struct kmod_module *mod,
 993                                         const char *options,
 994                                         struct probe_insert_cb *cb)
 995 {
 996         const char *command = kmod_module_get_install_commands(mod);
 997         char *p;
 998         _cleanup_free_ char *cmd;
 999         int err;
1000         size_t cmdlen, options_len, varlen;
1001
1002         assert(command);
1003
1004         if (options == NULL)
1005                 options = "";
1006
1007         options_len = strlen(options);
1008         cmdlen = strlen(command);
1009         varlen = sizeof("$CMDLINE_OPTS") - 1;
1010
1011         cmd = memdup(command, cmdlen + 1);
1012         if (cmd == NULL)
1013                 return -ENOMEM;
1014
1015         while ((p = strstr(cmd, "$CMDLINE_OPTS")) != NULL) {
1016                 size_t prefixlen = p - cmd;
1017                 size_t suffixlen = cmdlen - prefixlen - varlen;
1018                 size_t slen = cmdlen - varlen + options_len;
1019                 char *suffix = p + varlen;
1020                 char *s = malloc(slen + 1);
1021                 if (!s)
1022                         return -ENOMEM;
1023
1024                 memcpy(s, cmd, p - cmd);
1025                 memcpy(s + prefixlen, options, options_len);
1026                 memcpy(s + prefixlen + options_len, suffix, suffixlen);
1027                 s[slen] = '\0';
1028
1029                 free(cmd);
1030                 cmd = s;
1031                 cmdlen = slen;
1032         }
1033
1034         if (cb->run_install != NULL)
1035                 err = cb->run_install(mod, cmd, cb->data);
1036         else
1037                 err = command_do(mod, "install", cmd);
1038
1039         return err;
1040 }
1041
1042 static char *module_options_concat(const char *opt, const char *xopt)
1043 {
1044         // TODO: we might need to check if xopt overrides options on opt
1045         size_t optlen = opt == NULL ? 0 : strlen(opt);
1046         size_t xoptlen = xopt == NULL ? 0 : strlen(xopt);
1047         char *r;
1048
1049         if (optlen == 0 && xoptlen == 0)
1050                 return NULL;
1051
1052         r = malloc(optlen + xoptlen + 2);
1053
1054         if (opt != NULL) {
1055                 memcpy(r, opt, optlen);
1056                 r[optlen] = ' ';
1057                 optlen++;
1058         }
1059
1060         if (xopt != NULL)
1061                 memcpy(r + optlen, xopt, xoptlen);
1062
1063         r[optlen + xoptlen] = '\0';
1064
1065         return r;
1066 }
1067
1068 static int __kmod_module_get_probe_list(struct kmod_module *mod,
1069                                                 bool required,
1070                                                 bool ignorecmd,
1071                                                 struct kmod_list **list);
1072
1073 /* re-entrant */
1074 static int __kmod_module_fill_softdep(struct kmod_module *mod,
1075                                                 struct kmod_list **list)
1076 {
1077         struct kmod_list *pre = NULL, *post = NULL, *l;
1078         int err;
1079
1080         err = kmod_module_get_softdeps(mod, &pre, &post);
1081         if (err < 0) {
1082                 ERR(mod->ctx, "could not get softdep: %s\n",
1083                                                         strerror(-err));
1084                 goto fail;
1085         }
1086
1087         kmod_list_foreach(l, pre) {
1088                 struct kmod_module *m = l->data;
1089                 err = __kmod_module_get_probe_list(m, false, false, list);
1090                 if (err < 0)
1091                         goto fail;
1092         }
1093
1094         l = kmod_list_append(*list, kmod_module_ref(mod));
1095         if (l == NULL) {
1096                 kmod_module_unref(mod);
1097                 err = -ENOMEM;
1098                 goto fail;
1099         }
1100         *list = l;
1101         mod->ignorecmd = (pre != NULL || post != NULL);
1102
1103         kmod_list_foreach(l, post) {
1104                 struct kmod_module *m = l->data;
1105                 err = __kmod_module_get_probe_list(m, false, false, list);
1106                 if (err < 0)
1107                         goto fail;
1108         }
1109
1110 fail:
1111         kmod_module_unref_list(pre);
1112         kmod_module_unref_list(post);
1113
1114         return err;
1115 }
1116
1117 /* re-entrant */
1118 static int __kmod_module_get_probe_list(struct kmod_module *mod,
1119                                                 bool required,
1120                                                 bool ignorecmd,
1121                                                 struct kmod_list **list)
1122 {
1123         struct kmod_list *dep, *l;
1124         int err = 0;
1125
1126         if (mod->visited) {
1127                 DBG(mod->ctx, "Ignore module '%s': already visited\n",
1128                                                                 mod->name);
1129                 return 0;
1130         }
1131         mod->visited = true;
1132
1133         dep = kmod_module_get_dependencies(mod);
1134         if (required) {
1135                 /*
1136                  * Called from kmod_module_probe_insert_module(); set the
1137                  * ->required flag on mod and all its dependencies before
1138                  * they are possibly visited through some softdeps.
1139                  */
1140                 mod->required = true;
1141                 kmod_list_foreach(l, dep) {
1142                         struct kmod_module *m = l->data;
1143                         m->required = true;
1144                 }
1145         }
1146
1147         kmod_list_foreach(l, dep) {
1148                 struct kmod_module *m = l->data;
1149                 err = __kmod_module_fill_softdep(m, list);
1150                 if (err < 0)
1151                         goto finish;
1152         }
1153
1154         if (ignorecmd) {
1155                 l = kmod_list_append(*list, kmod_module_ref(mod));
1156                 if (l == NULL) {
1157                         kmod_module_unref(mod);
1158                         err = -ENOMEM;
1159                         goto finish;
1160                 }
1161                 *list = l;
1162                 mod->ignorecmd = true;
1163         } else
1164                 err = __kmod_module_fill_softdep(mod, list);
1165
1166 finish:
1167         kmod_module_unref_list(dep);
1168         return err;
1169 }
1170
1171 static int kmod_module_get_probe_list(struct kmod_module *mod,
1172                                                 bool ignorecmd,
1173                                                 struct kmod_list **list)
1174 {
1175         int err;
1176
1177         assert(mod != NULL);
1178         assert(list != NULL && *list == NULL);
1179
1180         /*
1181          * Make sure we don't get screwed by previous calls to this function
1182          */
1183         kmod_set_modules_visited(mod->ctx, false);
1184         kmod_set_modules_required(mod->ctx, false);
1185
1186         err = __kmod_module_get_probe_list(mod, true, ignorecmd, list);
1187         if (err < 0) {
1188                 kmod_module_unref_list(*list);
1189                 *list = NULL;
1190         }
1191
1192         return err;
1193 }
1194
1195 /**
1196  * kmod_module_probe_insert_module:
1197  * @mod: kmod module
1198  * @flags: flags are not passed to Linux Kernel, but instead they dictate the
1199  * behavior of this function, valid flags are
1200  * KMOD_PROBE_FORCE_VERMAGIC: ignore kernel version magic;
1201  * KMOD_PROBE_FORCE_MODVERSION: ignore symbol version hashes;
1202  * KMOD_PROBE_IGNORE_COMMAND: whether the probe should ignore install
1203  * commands and softdeps configured in the system;
1204  * KMOD_PROBE_IGNORE_LOADED: do not check whether the module is already
1205  * live in kernel or not;
1206  * KMOD_PROBE_DRY_RUN: dry run, do not insert module, just call the
1207  * associated callback function;
1208  * KMOD_PROBE_FAIL_ON_LOADED: if KMOD_PROBE_IGNORE_LOADED is not specified
1209  * and the module is already live in kernel, the function will fail if this
1210  * flag is specified;
1211  * KMOD_PROBE_APPLY_BLACKLIST_ALL: probe will apply KMOD_FILTER_BLACKLIST
1212  * filter to this module and its dependencies. If any of the dependencies (or
1213  * the module) is blacklisted, the probe will fail, unless the blacklisted
1214  * module is already live in kernel;
1215  * KMOD_PROBE_APPLY_BLACKLIST: probe will fail if the module is blacklisted;
1216  * KMOD_PROBE_APPLY_BLACKLIST_ALIAS_ONLY: probe will fail if the module is an
1217  * alias and is blacklisted.
1218  * @extra_options: module's options to pass to Linux Kernel. It applies only
1219  * to @mod, not to its dependencies.
1220  * @run_install: function to run when @mod is backed by an install command.
1221  * @data: data to give back to @run_install callback
1222  * @print_action: function to call with the action being taken (install or
1223  * insmod). It's useful for tools like modprobe when running with verbose
1224  * output or in dry-run mode.
1225  *
1226  * Insert a module in Linux kernel resolving dependencies, soft dependencies,
1227  * install commands and applying blacklist.
1228  *
1229  * If @run_install is NULL, this function will fork and exec by calling
1230  * system(3). Don't pass a NULL argument in @run_install if your binary is
1231  * setuid/setgid (see warning in system(3)). If you need control over the
1232  * execution of an install command, give a callback function instead.
1233  *
1234  * Returns: 0 on success, > 0 if stopped by a reason given in @flags or < 0 on
1235  * failure.
1236  */
1237 KMOD_EXPORT int kmod_module_probe_insert_module(struct kmod_module *mod,
1238                         unsigned int flags, const char *extra_options,
1239                         int (*run_install)(struct kmod_module *m,
1240                                                 const char *cmd, void *data),
1241                         const void *data,
1242                         void (*print_action)(struct kmod_module *m,
1243                                                 bool install,
1244                                                 const char *options))
1245 {
1246         struct kmod_list *list = NULL, *l;
1247         struct probe_insert_cb cb;
1248         int err;
1249
1250         if (mod == NULL)
1251                 return -ENOENT;
1252
1253         if (!(flags & KMOD_PROBE_IGNORE_LOADED)
1254                                         && module_is_inkernel(mod)) {
1255                 if (flags & KMOD_PROBE_FAIL_ON_LOADED)
1256                         return -EEXIST;
1257                 else
1258                         return 0;
1259         }
1260
1261         /*
1262          * Ugly assignement + check. We need to check if we were told to check
1263          * blacklist and also return the reason why we failed.
1264          * KMOD_PROBE_APPLY_BLACKLIST_ALIAS_ONLY will take effect only if the
1265          * module is an alias, so we also need to check it
1266          */
1267         if ((mod->alias != NULL && ((err = flags & KMOD_PROBE_APPLY_BLACKLIST_ALIAS_ONLY)))
1268                         || (err = flags & KMOD_PROBE_APPLY_BLACKLIST_ALL)
1269                         || (err = flags & KMOD_PROBE_APPLY_BLACKLIST)) {
1270                 if (module_is_blacklisted(mod))
1271                         return err;
1272         }
1273
1274         err = kmod_module_get_probe_list(mod,
1275                                 !!(flags & KMOD_PROBE_IGNORE_COMMAND), &list);
1276         if (err < 0)
1277                 return err;
1278
1279         if (flags & KMOD_PROBE_APPLY_BLACKLIST_ALL) {
1280                 struct kmod_list *filtered = NULL;
1281
1282                 err = kmod_module_apply_filter(mod->ctx,
1283                                 KMOD_FILTER_BLACKLIST, list, &filtered);
1284                 if (err < 0)
1285                         return err;
1286
1287                 kmod_module_unref_list(list);
1288                 if (filtered == NULL)
1289                         return KMOD_PROBE_APPLY_BLACKLIST_ALL;
1290
1291                 list = filtered;
1292         }
1293
1294         cb.run_install = run_install;
1295         cb.data = (void *) data;
1296
1297         kmod_list_foreach(l, list) {
1298                 struct kmod_module *m = l->data;
1299                 const char *moptions = kmod_module_get_options(m);
1300                 const char *cmd = kmod_module_get_install_commands(m);
1301                 char *options;
1302
1303                 if (!(flags & KMOD_PROBE_IGNORE_LOADED)
1304                                                 && module_is_inkernel(m)) {
1305                         DBG(mod->ctx, "Ignoring module '%s': already loaded\n",
1306                                                                 m->name);
1307                         err = -EEXIST;
1308                         goto finish_module;
1309                 }
1310
1311                 options = module_options_concat(moptions,
1312                                         m == mod ? extra_options : NULL);
1313
1314                 if (cmd != NULL && !m->ignorecmd) {
1315                         if (print_action != NULL)
1316                                 print_action(m, true, options ?: "");
1317
1318                         if (!(flags & KMOD_PROBE_DRY_RUN))
1319                                 err = module_do_install_commands(m, options,
1320                                                                         &cb);
1321                 } else {
1322                         if (print_action != NULL)
1323                                 print_action(m, false, options ?: "");
1324
1325                         if (!(flags & KMOD_PROBE_DRY_RUN))
1326                                 err = kmod_module_insert_module(m, flags,
1327                                                                 options);
1328                 }
1329
1330                 free(options);
1331
1332 finish_module:
1333                 /*
1334                  * Treat "already loaded" error. If we were told to stop on
1335                  * already loaded and the module being loaded is not a softdep
1336                  * or dep, bail out. Otherwise, just ignore and continue.
1337                  *
1338                  * We need to check here because of race conditions. We
1339                  * checked first if module was already loaded but it may have
1340                  * been loaded between the check and the moment we try to
1341                  * insert it.
1342                  */
1343                 if (err == -EEXIST && m == mod &&
1344                                 (flags & KMOD_PROBE_FAIL_ON_LOADED))
1345                         break;
1346
1347                 /*
1348                  * Ignore errors from softdeps
1349                  */
1350                 if (err == -EEXIST || !m->required)
1351                         err = 0;
1352
1353                 else if (err < 0)
1354                         break;
1355         }
1356
1357         kmod_module_unref_list(list);
1358         return err;
1359 }
1360
1361 /**
1362  * kmod_module_get_options:
1363  * @mod: kmod module
1364  *
1365  * Get options of this kmod module. Options come from the configuration file
1366  * and are cached in @mod. The first call to this function will search for
1367  * this module in configuration and subsequent calls return the cached string.
1368  *
1369  * Returns: a string with all the options separated by spaces. This string is
1370  * owned by @mod, do not free it.
1371  */
1372 KMOD_EXPORT const char *kmod_module_get_options(const struct kmod_module *mod)
1373 {
1374         if (mod == NULL)
1375                 return NULL;
1376
1377         if (!mod->init.options) {
1378                 /* lazy init */
1379                 struct kmod_module *m = (struct kmod_module *)mod;
1380                 const struct kmod_list *l;
1381                 const struct kmod_config *config;
1382                 char *opts = NULL;
1383                 size_t optslen = 0;
1384
1385                 config = kmod_get_config(mod->ctx);
1386
1387                 kmod_list_foreach(l, config->options) {
1388                         const char *modname = kmod_option_get_modname(l);
1389                         const char *str;
1390                         size_t len;
1391                         void *tmp;
1392
1393                         DBG(mod->ctx, "modname=%s mod->name=%s mod->alias=%s\n", modname, mod->name, mod->alias);
1394                         if (!(streq(modname, mod->name) || (mod->alias != NULL &&
1395                                                 streq(modname, mod->alias))))
1396                                 continue;
1397
1398                         DBG(mod->ctx, "passed = modname=%s mod->name=%s mod->alias=%s\n", modname, mod->name, mod->alias);
1399                         str = kmod_option_get_options(l);
1400                         len = strlen(str);
1401                         if (len < 1)
1402                                 continue;
1403
1404                         tmp = realloc(opts, optslen + len + 2);
1405                         if (tmp == NULL) {
1406                                 free(opts);
1407                                 goto failed;
1408                         }
1409
1410                         opts = tmp;
1411
1412                         if (optslen > 0) {
1413                                 opts[optslen] = ' ';
1414                                 optslen++;
1415                         }
1416
1417                         memcpy(opts + optslen, str, len);
1418                         optslen += len;
1419                         opts[optslen] = '\0';
1420                 }
1421
1422                 m->init.options = true;
1423                 m->options = opts;
1424         }
1425
1426         return mod->options;
1427
1428 failed:
1429         ERR(mod->ctx, "out of memory\n");
1430         return NULL;
1431 }
1432
1433 /**
1434  * kmod_module_get_install_commands:
1435  * @mod: kmod module
1436  *
1437  * Get install commands for this kmod module. Install commands come from the
1438  * configuration file and are cached in @mod. The first call to this function
1439  * will search for this module in configuration and subsequent calls return
1440  * the cached string. The install commands are returned as they were in the
1441  * configuration, concatenated by ';'. No other processing is made in this
1442  * string.
1443  *
1444  * Returns: a string with all install commands separated by semicolons. This
1445  * string is owned by @mod, do not free it.
1446  */
1447 KMOD_EXPORT const char *kmod_module_get_install_commands(const struct kmod_module *mod)
1448 {
1449         if (mod == NULL)
1450                 return NULL;
1451
1452         if (!mod->init.install_commands) {
1453                 /* lazy init */
1454                 struct kmod_module *m = (struct kmod_module *)mod;
1455                 const struct kmod_list *l;
1456                 const struct kmod_config *config;
1457
1458                 config = kmod_get_config(mod->ctx);
1459
1460                 kmod_list_foreach(l, config->install_commands) {
1461                         const char *modname = kmod_command_get_modname(l);
1462
1463                         if (fnmatch(modname, mod->name, 0) != 0)
1464                                 continue;
1465
1466                         m->install_commands = kmod_command_get_command(l);
1467
1468                         /*
1469                          * find only the first command, as modprobe from
1470                          * module-init-tools does
1471                          */
1472                         break;
1473                 }
1474
1475                 m->init.install_commands = true;
1476         }
1477
1478         return mod->install_commands;
1479 }
1480
1481 void kmod_module_set_install_commands(struct kmod_module *mod, const char *cmd)
1482 {
1483         mod->init.install_commands = true;
1484         mod->install_commands = cmd;
1485 }
1486
1487 static struct kmod_list *lookup_softdep(struct kmod_ctx *ctx, const char * const * array, unsigned int count)
1488 {
1489         struct kmod_list *ret = NULL;
1490         unsigned i;
1491
1492         for (i = 0; i < count; i++) {
1493                 const char *depname = array[i];
1494                 struct kmod_list *lst = NULL;
1495                 int err;
1496
1497                 err = kmod_module_new_from_lookup(ctx, depname, &lst);
1498                 if (err < 0) {
1499                         ERR(ctx, "failed to lookup soft dependency '%s', continuing anyway.\n", depname);
1500                         continue;
1501                 } else if (lst != NULL)
1502                         ret = kmod_list_append_list(ret, lst);
1503         }
1504         return ret;
1505 }
1506
1507 /**
1508  * kmod_module_get_softdeps:
1509  * @mod: kmod module
1510  * @pre: where to save the list of preceding soft dependencies.
1511  * @post: where to save the list of post soft dependencies.
1512  *
1513  * Get soft dependencies for this kmod module. Soft dependencies come
1514  * from configuration file and are not cached in @mod because it may include
1515  * dependency cycles that would make we leak kmod_module. Any call
1516  * to this function will search for this module in configuration, allocate a
1517  * list and return the result.
1518  *
1519  * Both @pre and @post are newly created list of kmod_module and
1520  * should be unreferenced with kmod_module_unref_list().
1521  *
1522  * Returns: 0 on success or < 0 otherwise.
1523  */
1524 KMOD_EXPORT int kmod_module_get_softdeps(const struct kmod_module *mod,
1525                                                 struct kmod_list **pre,
1526                                                 struct kmod_list **post)
1527 {
1528         const struct kmod_list *l;
1529         const struct kmod_config *config;
1530
1531         if (mod == NULL || pre == NULL || post == NULL)
1532                 return -ENOENT;
1533
1534         assert(*pre == NULL);
1535         assert(*post == NULL);
1536
1537         config = kmod_get_config(mod->ctx);
1538
1539         kmod_list_foreach(l, config->softdeps) {
1540                 const char *modname = kmod_softdep_get_name(l);
1541                 const char * const *array;
1542                 unsigned count;
1543
1544                 if (fnmatch(modname, mod->name, 0) != 0)
1545                         continue;
1546
1547                 array = kmod_softdep_get_pre(l, &count);
1548                 *pre = lookup_softdep(mod->ctx, array, count);
1549                 array = kmod_softdep_get_post(l, &count);
1550                 *post = lookup_softdep(mod->ctx, array, count);
1551
1552                 /*
1553                  * find only the first command, as modprobe from
1554                  * module-init-tools does
1555                  */
1556                 break;
1557         }
1558
1559         return 0;
1560 }
1561
1562 /**
1563  * kmod_module_get_remove_commands:
1564  * @mod: kmod module
1565  *
1566  * Get remove commands for this kmod module. Remove commands come from the
1567  * configuration file and are cached in @mod. The first call to this function
1568  * will search for this module in configuration and subsequent calls return
1569  * the cached string. The remove commands are returned as they were in the
1570  * configuration, concatenated by ';'. No other processing is made in this
1571  * string.
1572  *
1573  * Returns: a string with all remove commands separated by semicolons. This
1574  * string is owned by @mod, do not free it.
1575  */
1576 KMOD_EXPORT const char *kmod_module_get_remove_commands(const struct kmod_module *mod)
1577 {
1578         if (mod == NULL)
1579                 return NULL;
1580
1581         if (!mod->init.remove_commands) {
1582                 /* lazy init */
1583                 struct kmod_module *m = (struct kmod_module *)mod;
1584                 const struct kmod_list *l;
1585                 const struct kmod_config *config;
1586
1587                 config = kmod_get_config(mod->ctx);
1588
1589                 kmod_list_foreach(l, config->remove_commands) {
1590                         const char *modname = kmod_command_get_modname(l);
1591
1592                         if (fnmatch(modname, mod->name, 0) != 0)
1593                                 continue;
1594
1595                         m->remove_commands = kmod_command_get_command(l);
1596
1597                         /*
1598                          * find only the first command, as modprobe from
1599                          * module-init-tools does
1600                          */
1601                         break;
1602                 }
1603
1604                 m->init.remove_commands = true;
1605         }
1606
1607         return mod->remove_commands;
1608 }
1609
1610 void kmod_module_set_remove_commands(struct kmod_module *mod, const char *cmd)
1611 {
1612         mod->init.remove_commands = true;
1613         mod->remove_commands = cmd;
1614 }
1615
1616 /**
1617  * SECTION:libkmod-loaded
1618  * @short_description: currently loaded modules
1619  *
1620  * Information about currently loaded modules, as reported by Linux kernel.
1621  * These information are not cached by libkmod and are always read from /sys
1622  * and /proc/modules.
1623  */
1624
1625 /**
1626  * kmod_module_new_from_loaded:
1627  * @ctx: kmod library context
1628  * @list: where to save the list of loaded modules
1629  *
1630  * Create a new list of kmod modules with all modules currently loaded in
1631  * kernel. It uses /proc/modules to get the names of loaded modules and to
1632  * create kmod modules by calling kmod_module_new_from_name() in each of them.
1633  * They are put in @list in no particular order.
1634  *
1635  * The initial refcount is 1, and needs to be decremented to release the
1636  * resources of the kmod_module. The returned @list must be released by
1637  * calling kmod_module_unref_list(). Since libkmod keeps track of all
1638  * kmod_modules created, they are all released upon @ctx destruction too. Do
1639  * not unref @ctx before all the desired operations with the returned list are
1640  * completed.
1641  *
1642  * Returns: 0 on success or < 0 on error.
1643  */
1644 KMOD_EXPORT int kmod_module_new_from_loaded(struct kmod_ctx *ctx,
1645                                                 struct kmod_list **list)
1646 {
1647         struct kmod_list *l = NULL;
1648         FILE *fp;
1649         char line[4096];
1650
1651         if (ctx == NULL || list == NULL)
1652                 return -ENOENT;
1653
1654         fp = fopen("/proc/modules", "re");
1655         if (fp == NULL) {
1656                 int err = -errno;
1657                 ERR(ctx, "could not open /proc/modules: %s\n", strerror(errno));
1658                 return err;
1659         }
1660
1661         while (fgets(line, sizeof(line), fp)) {
1662                 struct kmod_module *m;
1663                 struct kmod_list *node;
1664                 int err;
1665                 size_t len = strlen(line);
1666                 char *saveptr, *name = strtok_r(line, " \t", &saveptr);
1667
1668                 err = kmod_module_new_from_name(ctx, name, &m);
1669                 if (err < 0) {
1670                         ERR(ctx, "could not get module from name '%s': %s\n",
1671                                 name, strerror(-err));
1672                         goto eat_line;
1673                 }
1674
1675                 node = kmod_list_append(l, m);
1676                 if (node)
1677                         l = node;
1678                 else {
1679                         ERR(ctx, "out of memory\n");
1680                         kmod_module_unref(m);
1681                 }
1682 eat_line:
1683                 while (line[len - 1] != '\n' && fgets(line, sizeof(line), fp))
1684                         len = strlen(line);
1685         }
1686
1687         fclose(fp);
1688         *list = l;
1689
1690         return 0;
1691 }
1692
1693 /**
1694  * kmod_module_initstate_str:
1695  * @state: the state as returned by kmod_module_get_initstate()
1696  *
1697  * Translate a initstate to a string.
1698  *
1699  * Returns: the string associated to the @state. This string is statically
1700  * allocated, do not free it.
1701  */
1702 KMOD_EXPORT const char *kmod_module_initstate_str(enum kmod_module_initstate state)
1703 {
1704         switch (state) {
1705         case KMOD_MODULE_BUILTIN:
1706                 return "builtin";
1707         case KMOD_MODULE_LIVE:
1708                 return "live";
1709         case KMOD_MODULE_COMING:
1710                 return "coming";
1711         case KMOD_MODULE_GOING:
1712                 return "going";
1713         default:
1714                 return NULL;
1715         }
1716 }
1717
1718 /**
1719  * kmod_module_get_initstate:
1720  * @mod: kmod module
1721  *
1722  * Get the initstate of this @mod, as returned by Linux Kernel, by reading
1723  * /sys filesystem.
1724  *
1725  * Returns: < 0 on error or module state if module is found in kernel, valid states are
1726  * KMOD_MODULE_BUILTIN: module is builtin;
1727  * KMOD_MODULE_LIVE: module is live in kernel;
1728  * KMOD_MODULE_COMING: module is being loaded;
1729  * KMOD_MODULE_GOING: module is being unloaded.
1730  */
1731 KMOD_EXPORT int kmod_module_get_initstate(const struct kmod_module *mod)
1732 {
1733         char path[PATH_MAX], buf[32];
1734         int fd, err, pathlen;
1735
1736         if (mod == NULL)
1737                 return -ENOENT;
1738
1739         /* remove const: this can only change internal state */
1740         if (kmod_module_is_builtin((struct kmod_module *)mod))
1741                 return KMOD_MODULE_BUILTIN;
1742
1743         pathlen = snprintf(path, sizeof(path),
1744                                 "/sys/module/%s/initstate", mod->name);
1745         fd = open(path, O_RDONLY|O_CLOEXEC);
1746         if (fd < 0) {
1747                 err = -errno;
1748
1749                 DBG(mod->ctx, "could not open '%s': %s\n",
1750                         path, strerror(-err));
1751
1752                 if (pathlen > (int)sizeof("/initstate") - 1) {
1753                         struct stat st;
1754                         path[pathlen - (sizeof("/initstate") - 1)] = '\0';
1755                         if (stat(path, &st) == 0 && S_ISDIR(st.st_mode))
1756                                 return KMOD_MODULE_COMING;
1757                 }
1758
1759                 DBG(mod->ctx, "could not open '%s': %s\n",
1760                         path, strerror(-err));
1761                 return err;
1762         }
1763
1764         err = read_str_safe(fd, buf, sizeof(buf));
1765         close(fd);
1766         if (err < 0) {
1767                 ERR(mod->ctx, "could not read from '%s': %s\n",
1768                         path, strerror(-err));
1769                 return err;
1770         }
1771
1772         if (streq(buf, "live\n"))
1773                 return KMOD_MODULE_LIVE;
1774         else if (streq(buf, "coming\n"))
1775                 return KMOD_MODULE_COMING;
1776         else if (streq(buf, "going\n"))
1777                 return KMOD_MODULE_GOING;
1778
1779         ERR(mod->ctx, "unknown %s: '%s'\n", path, buf);
1780         return -EINVAL;
1781 }
1782
1783 /**
1784  * kmod_module_get_size:
1785  * @mod: kmod module
1786  *
1787  * Get the size of this kmod module as returned by Linux kernel. If supported,
1788  * the size is read from the coresize attribute in /sys/module. For older
1789  * kernels, this falls back on /proc/modules and searches for the specified
1790  * module to get its size.
1791  *
1792  * Returns: the size of this kmod module.
1793  */
1794 KMOD_EXPORT long kmod_module_get_size(const struct kmod_module *mod)
1795 {
1796         FILE *fp;
1797         char line[4096];
1798         int lineno = 0;
1799         long size = -ENOENT;
1800         int dfd, cfd;
1801
1802         if (mod == NULL)
1803                 return -ENOENT;
1804
1805         /* try to open the module dir in /sys. If this fails, don't
1806          * bother trying to find the size as we know the module isn't
1807          * loaded.
1808          */
1809         snprintf(line, sizeof(line), "/sys/module/%s", mod->name);
1810         dfd = open(line, O_RDONLY|O_CLOEXEC);
1811         if (dfd < 0)
1812                 return -errno;
1813
1814         /* available as of linux 3.3.x */
1815         cfd = openat(dfd, "coresize", O_RDONLY|O_CLOEXEC);
1816         if (cfd >= 0) {
1817                 if (read_str_long(cfd, &size, 10) < 0)
1818                         ERR(mod->ctx, "failed to read coresize from %s\n", line);
1819                 close(cfd);
1820                 goto done;
1821         }
1822
1823         /* fall back on parsing /proc/modules */
1824         fp = fopen("/proc/modules", "re");
1825         if (fp == NULL) {
1826                 int err = -errno;
1827                 ERR(mod->ctx,
1828                     "could not open /proc/modules: %s\n", strerror(errno));
1829                 close(dfd);
1830                 return err;
1831         }
1832
1833         while (fgets(line, sizeof(line), fp)) {
1834                 size_t len = strlen(line);
1835                 char *saveptr, *endptr, *tok = strtok_r(line, " \t", &saveptr);
1836                 long value;
1837
1838                 lineno++;
1839                 if (tok == NULL || !streq(tok, mod->name))
1840                         goto eat_line;
1841
1842                 tok = strtok_r(NULL, " \t", &saveptr);
1843                 if (tok == NULL) {
1844                         ERR(mod->ctx,
1845                         "invalid line format at /proc/modules:%d\n", lineno);
1846                         break;
1847                 }
1848
1849                 value = strtol(tok, &endptr, 10);
1850                 if (endptr == tok || *endptr != '\0') {
1851                         ERR(mod->ctx,
1852                         "invalid line format at /proc/modules:%d\n", lineno);
1853                         break;
1854                 }
1855
1856                 size = value;
1857                 break;
1858 eat_line:
1859                 while (line[len - 1] != '\n' && fgets(line, sizeof(line), fp))
1860                         len = strlen(line);
1861         }
1862         fclose(fp);
1863
1864 done:
1865         close(dfd);
1866         return size;
1867 }
1868
1869 /**
1870  * kmod_module_get_refcnt:
1871  * @mod: kmod module
1872  *
1873  * Get the ref count of this @mod, as returned by Linux Kernel, by reading
1874  * /sys filesystem.
1875  *
1876  * Returns: the reference count on success or < 0 on failure.
1877  */
1878 KMOD_EXPORT int kmod_module_get_refcnt(const struct kmod_module *mod)
1879 {
1880         char path[PATH_MAX];
1881         long refcnt;
1882         int fd, err;
1883
1884         if (mod == NULL)
1885                 return -ENOENT;
1886
1887         snprintf(path, sizeof(path), "/sys/module/%s/refcnt", mod->name);
1888         fd = open(path, O_RDONLY|O_CLOEXEC);
1889         if (fd < 0) {
1890                 err = -errno;
1891                 DBG(mod->ctx, "could not open '%s': %s\n",
1892                         path, strerror(errno));
1893                 return err;
1894         }
1895
1896         err = read_str_long(fd, &refcnt, 10);
1897         close(fd);
1898         if (err < 0) {
1899                 ERR(mod->ctx, "could not read integer from '%s': '%s'\n",
1900                         path, strerror(-err));
1901                 return err;
1902         }
1903
1904         return (int)refcnt;
1905 }
1906
1907 /**
1908  * kmod_module_get_holders:
1909  * @mod: kmod module
1910  *
1911  * Get a list of kmod modules that are holding this @mod, as returned by Linux
1912  * Kernel. After use, free the @list by calling kmod_module_unref_list().
1913  *
1914  * Returns: a new list of kmod modules on success or NULL on failure.
1915  */
1916 KMOD_EXPORT struct kmod_list *kmod_module_get_holders(const struct kmod_module *mod)
1917 {
1918         char dname[PATH_MAX];
1919         struct kmod_list *list = NULL;
1920         struct dirent *dent;
1921         DIR *d;
1922
1923         if (mod == NULL || mod->ctx == NULL)
1924                 return NULL;
1925
1926         snprintf(dname, sizeof(dname), "/sys/module/%s/holders", mod->name);
1927
1928         d = opendir(dname);
1929         if (d == NULL) {
1930                 ERR(mod->ctx, "could not open '%s': %s\n",
1931                                                 dname, strerror(errno));
1932                 return NULL;
1933         }
1934
1935         for (dent = readdir(d); dent != NULL; dent = readdir(d)) {
1936                 struct kmod_module *holder;
1937                 struct kmod_list *l;
1938                 int err;
1939
1940                 if (dent->d_name[0] == '.') {
1941                         if (dent->d_name[1] == '\0' ||
1942                             (dent->d_name[1] == '.' && dent->d_name[2] == '\0'))
1943                                 continue;
1944                 }
1945
1946                 err = kmod_module_new_from_name(mod->ctx, dent->d_name,
1947                                                 &holder);
1948                 if (err < 0) {
1949                         ERR(mod->ctx, "could not create module for '%s': %s\n",
1950                                 dent->d_name, strerror(-err));
1951                         goto fail;
1952                 }
1953
1954                 l = kmod_list_append(list, holder);
1955                 if (l != NULL) {
1956                         list = l;
1957                 } else {
1958                         ERR(mod->ctx, "out of memory\n");
1959                         kmod_module_unref(holder);
1960                         goto fail;
1961                 }
1962         }
1963
1964         closedir(d);
1965         return list;
1966
1967 fail:
1968         closedir(d);
1969         kmod_module_unref_list(list);
1970         return NULL;
1971 }
1972
1973 struct kmod_module_section {
1974         unsigned long address;
1975         char name[];
1976 };
1977
1978 static void kmod_module_section_free(struct kmod_module_section *section)
1979 {
1980         free(section);
1981 }
1982
1983 /**
1984  * kmod_module_get_sections:
1985  * @mod: kmod module
1986  *
1987  * Get a list of kmod sections of this @mod, as returned by Linux Kernel. The
1988  * structure contained in this list is internal to libkmod and their fields
1989  * can be obtained by calling kmod_module_section_get_name() and
1990  * kmod_module_section_get_address().
1991  *
1992  * After use, free the @list by calling kmod_module_section_free_list().
1993  *
1994  * Returns: a new list of kmod module sections on success or NULL on failure.
1995  */
1996 KMOD_EXPORT struct kmod_list *kmod_module_get_sections(const struct kmod_module *mod)
1997 {
1998         char dname[PATH_MAX];
1999         struct kmod_list *list = NULL;
2000         struct dirent *dent;
2001         DIR *d;
2002         int dfd;
2003
2004         if (mod == NULL)
2005                 return NULL;
2006
2007         snprintf(dname, sizeof(dname), "/sys/module/%s/sections", mod->name);
2008
2009         d = opendir(dname);
2010         if (d == NULL) {
2011                 ERR(mod->ctx, "could not open '%s': %s\n",
2012                         dname, strerror(errno));
2013                 return NULL;
2014         }
2015
2016         dfd = dirfd(d);
2017
2018         for (dent = readdir(d); dent; dent = readdir(d)) {
2019                 struct kmod_module_section *section;
2020                 struct kmod_list *l;
2021                 unsigned long address;
2022                 size_t namesz;
2023                 int fd, err;
2024
2025                 if (dent->d_name[0] == '.') {
2026                         if (dent->d_name[1] == '\0' ||
2027                             (dent->d_name[1] == '.' && dent->d_name[2] == '\0'))
2028                                 continue;
2029                 }
2030
2031                 fd = openat(dfd, dent->d_name, O_RDONLY|O_CLOEXEC);
2032                 if (fd < 0) {
2033                         ERR(mod->ctx, "could not open '%s/%s': %m\n",
2034                                                         dname, dent->d_name);
2035                         goto fail;
2036                 }
2037
2038                 err = read_str_ulong(fd, &address, 16);
2039                 close(fd);
2040                 if (err < 0) {
2041                         ERR(mod->ctx, "could not read long from '%s/%s': %m\n",
2042                                                         dname, dent->d_name);
2043                         goto fail;
2044                 }
2045
2046                 namesz = strlen(dent->d_name) + 1;
2047                 section = malloc(sizeof(*section) + namesz);
2048
2049                 if (section == NULL) {
2050                         ERR(mod->ctx, "out of memory\n");
2051                         goto fail;
2052                 }
2053
2054                 section->address = address;
2055                 memcpy(section->name, dent->d_name, namesz);
2056
2057                 l = kmod_list_append(list, section);
2058                 if (l != NULL) {
2059                         list = l;
2060                 } else {
2061                         ERR(mod->ctx, "out of memory\n");
2062                         free(section);
2063                         goto fail;
2064                 }
2065         }
2066
2067         closedir(d);
2068         return list;
2069
2070 fail:
2071         closedir(d);
2072         kmod_module_unref_list(list);
2073         return NULL;
2074 }
2075
2076 /**
2077  * kmod_module_section_get_module_name:
2078  * @entry: a list entry representing a kmod module section
2079  *
2080  * Get the name of a kmod module section.
2081  *
2082  * After use, free the @list by calling kmod_module_section_free_list().
2083  *
2084  * Returns: the name of this kmod module section on success or NULL on
2085  * failure. The string is owned by the section, do not free it.
2086  */
2087 KMOD_EXPORT const char *kmod_module_section_get_name(const struct kmod_list *entry)
2088 {
2089         struct kmod_module_section *section;
2090
2091         if (entry == NULL)
2092                 return NULL;
2093
2094         section = entry->data;
2095         return section->name;
2096 }
2097
2098 /**
2099  * kmod_module_section_get_address:
2100  * @entry: a list entry representing a kmod module section
2101  *
2102  * Get the address of a kmod module section.
2103  *
2104  * After use, free the @list by calling kmod_module_section_free_list().
2105  *
2106  * Returns: the address of this kmod module section on success or ULONG_MAX
2107  * on failure.
2108  */
2109 KMOD_EXPORT unsigned long kmod_module_section_get_address(const struct kmod_list *entry)
2110 {
2111         struct kmod_module_section *section;
2112
2113         if (entry == NULL)
2114                 return (unsigned long)-1;
2115
2116         section = entry->data;
2117         return section->address;
2118 }
2119
2120 /**
2121  * kmod_module_section_free_list:
2122  * @list: kmod module section list
2123  *
2124  * Release the resources taken by @list
2125  */
2126 KMOD_EXPORT void kmod_module_section_free_list(struct kmod_list *list)
2127 {
2128         while (list) {
2129                 kmod_module_section_free(list->data);
2130                 list = kmod_list_remove(list);
2131         }
2132 }
2133
2134 static struct kmod_elf *kmod_module_get_elf(const struct kmod_module *mod)
2135 {
2136         if (mod->file == NULL) {
2137                 const char *path = kmod_module_get_path(mod);
2138
2139                 if (path == NULL) {
2140                         errno = ENOENT;
2141                         return NULL;
2142                 }
2143
2144                 ((struct kmod_module *)mod)->file = kmod_file_open(mod->ctx,
2145                                                                         path);
2146                 if (mod->file == NULL)
2147                         return NULL;
2148         }
2149
2150         return kmod_file_get_elf(mod->file);
2151 }
2152
2153 struct kmod_module_info {
2154         char *key;
2155         char value[];
2156 };
2157
2158 static struct kmod_module_info *kmod_module_info_new(const char *key, size_t keylen, const char *value, size_t valuelen)
2159 {
2160         struct kmod_module_info *info;
2161
2162         info = malloc(sizeof(struct kmod_module_info) + keylen + valuelen + 2);
2163         if (info == NULL)
2164                 return NULL;
2165
2166         info->key = (char *)info + sizeof(struct kmod_module_info)
2167                     + valuelen + 1;
2168         memcpy(info->key, key, keylen);
2169         info->key[keylen] = '\0';
2170         memcpy(info->value, value, valuelen);
2171         info->value[valuelen] = '\0';
2172         return info;
2173 }
2174
2175 static void kmod_module_info_free(struct kmod_module_info *info)
2176 {
2177         free(info);
2178 }
2179
2180 static struct kmod_list *kmod_module_info_append(struct kmod_list **list, const char *key, size_t keylen, const char *value, size_t valuelen)
2181 {
2182         struct kmod_module_info *info;
2183         struct kmod_list *n;
2184
2185         info = kmod_module_info_new(key, keylen, value, valuelen);
2186         if (info == NULL)
2187                 return NULL;
2188         n = kmod_list_append(*list, info);
2189         if (n != NULL)
2190                 *list = n;
2191         else
2192                 kmod_module_info_free(info);
2193         return n;
2194 }
2195
2196 static char *kmod_module_hex_to_str(const char *hex, size_t len)
2197 {
2198         char *str;
2199         int i;
2200         int j;
2201         const size_t line_limit = 20;
2202         size_t str_len;
2203
2204         str_len = len * 3; /* XX: or XX\0 */
2205         str_len += ((str_len + line_limit - 1) / line_limit - 1) * 3; /* \n\t\t */
2206
2207         str = malloc(str_len);
2208         if (str == NULL)
2209                 return NULL;
2210
2211         for (i = 0, j = 0; i < (int)len; i++) {
2212                 j += sprintf(str + j, "%02X", (unsigned char)hex[i]);
2213                 if (i < (int)len - 1) {
2214                         str[j++] = ':';
2215
2216                         if ((i + 1) % line_limit == 0)
2217                                 j += sprintf(str + j, "\n\t\t");
2218                 }
2219         }
2220         return str;
2221 }
2222
2223 static struct kmod_list *kmod_module_info_append_hex(struct kmod_list **list,
2224                                                      const char *key,
2225                                                      size_t keylen,
2226                                                      const char *value,
2227                                                      size_t valuelen)
2228 {
2229         char *hex;
2230         struct kmod_list *n;
2231
2232         if (valuelen > 0) {
2233                 /* Display as 01:12:DE:AD:BE:EF:... */
2234                 hex = kmod_module_hex_to_str(value, valuelen);
2235                 if (hex == NULL)
2236                         goto list_error;
2237                 n = kmod_module_info_append(list, key, keylen, hex, strlen(hex));
2238                 free(hex);
2239                 if (n == NULL)
2240                         goto list_error;
2241         } else {
2242                 n = kmod_module_info_append(list, key, keylen, NULL, 0);
2243                 if (n == NULL)
2244                         goto list_error;
2245         }
2246
2247         return n;
2248
2249 list_error:
2250         return NULL;
2251 }
2252
2253 /**
2254  * kmod_module_get_info:
2255  * @mod: kmod module
2256  * @list: where to return list of module information. Use
2257  *        kmod_module_info_get_key() and
2258  *        kmod_module_info_get_value(). Release this list with
2259  *        kmod_module_info_free_list()
2260  *
2261  * Get a list of entries in ELF section ".modinfo", these contain
2262  * alias, license, depends, vermagic and other keys with respective
2263  * values. If the module is signed (CONFIG_MODULE_SIG), information
2264  * about the module signature is included as well: signer,
2265  * sig_key and sig_hashalgo.
2266  *
2267  * After use, free the @list by calling kmod_module_info_free_list().
2268  *
2269  * Returns: 0 on success or < 0 otherwise.
2270  */
2271 KMOD_EXPORT int kmod_module_get_info(const struct kmod_module *mod, struct kmod_list **list)
2272 {
2273         struct kmod_elf *elf;
2274         char **strings;
2275         int i, count, ret = -ENOMEM;
2276         struct kmod_signature_info sig_info;
2277
2278         if (mod == NULL || list == NULL)
2279                 return -ENOENT;
2280
2281         assert(*list == NULL);
2282
2283         elf = kmod_module_get_elf(mod);
2284         if (elf == NULL)
2285                 return -errno;
2286
2287         count = kmod_elf_get_strings(elf, ".modinfo", &strings);
2288         if (count < 0)
2289                 return count;
2290
2291         for (i = 0; i < count; i++) {
2292                 struct kmod_list *n;
2293                 const char *key, *value;
2294                 size_t keylen, valuelen;
2295
2296                 key = strings[i];
2297                 value = strchr(key, '=');
2298                 if (value == NULL) {
2299                         keylen = strlen(key);
2300                         valuelen = 0;
2301                         value = key;
2302                 } else {
2303                         keylen = value - key;
2304                         value++;
2305                         valuelen = strlen(value);
2306                 }
2307
2308                 n = kmod_module_info_append(list, key, keylen, value, valuelen);
2309                 if (n == NULL)
2310                         goto list_error;
2311         }
2312
2313         if (kmod_module_signature_info(mod->file, &sig_info)) {
2314                 struct kmod_list *n;
2315
2316                 n = kmod_module_info_append(list, "sig_id", strlen("sig_id"),
2317                                 sig_info.id_type, strlen(sig_info.id_type));
2318                 if (n == NULL)
2319                         goto list_error;
2320                 count++;
2321
2322                 n = kmod_module_info_append(list, "signer", strlen("signer"),
2323                                 sig_info.signer, sig_info.signer_len);
2324                 if (n == NULL)
2325                         goto list_error;
2326                 count++;
2327
2328
2329                 n = kmod_module_info_append_hex(list, "sig_key", strlen("sig_key"),
2330                                                 sig_info.key_id,
2331                                                 sig_info.key_id_len);
2332                 if (n == NULL)
2333                         goto list_error;
2334                 count++;
2335
2336                 n = kmod_module_info_append(list,
2337                                 "sig_hashalgo", strlen("sig_hashalgo"),
2338                                 sig_info.hash_algo, strlen(sig_info.hash_algo));
2339                 if (n == NULL)
2340                         goto list_error;
2341                 count++;
2342
2343                 /*
2344                  * Omit sig_info.algo for now, as these
2345                  * are currently constant.
2346                  */
2347                 n = kmod_module_info_append_hex(list, "signature",
2348                                                 strlen("signature"),
2349                                                 sig_info.sig,
2350                                                 sig_info.sig_len);
2351
2352                 if (n == NULL)
2353                         goto list_error;
2354                 count++;
2355
2356         }
2357         ret = count;
2358
2359 list_error:
2360         if (ret < 0) {
2361                 kmod_module_info_free_list(*list);
2362                 *list = NULL;
2363         }
2364         free(strings);
2365         return ret;
2366 }
2367
2368 /**
2369  * kmod_module_info_get_key:
2370  * @entry: a list entry representing a kmod module info
2371  *
2372  * Get the key of a kmod module info.
2373  *
2374  * Returns: the key of this kmod module info on success or NULL on
2375  * failure. The string is owned by the info, do not free it.
2376  */
2377 KMOD_EXPORT const char *kmod_module_info_get_key(const struct kmod_list *entry)
2378 {
2379         struct kmod_module_info *info;
2380
2381         if (entry == NULL)
2382                 return NULL;
2383
2384         info = entry->data;
2385         return info->key;
2386 }
2387
2388 /**
2389  * kmod_module_info_get_value:
2390  * @entry: a list entry representing a kmod module info
2391  *
2392  * Get the value of a kmod module info.
2393  *
2394  * Returns: the value of this kmod module info on success or NULL on
2395  * failure. The string is owned by the info, do not free it.
2396  */
2397 KMOD_EXPORT const char *kmod_module_info_get_value(const struct kmod_list *entry)
2398 {
2399         struct kmod_module_info *info;
2400
2401         if (entry == NULL)
2402                 return NULL;
2403
2404         info = entry->data;
2405         return info->value;
2406 }
2407
2408 /**
2409  * kmod_module_info_free_list:
2410  * @list: kmod module info list
2411  *
2412  * Release the resources taken by @list
2413  */
2414 KMOD_EXPORT void kmod_module_info_free_list(struct kmod_list *list)
2415 {
2416         while (list) {
2417                 kmod_module_info_free(list->data);
2418                 list = kmod_list_remove(list);
2419         }
2420 }
2421
2422 struct kmod_module_version {
2423         uint64_t crc;
2424         char symbol[];
2425 };
2426
2427 static struct kmod_module_version *kmod_module_versions_new(uint64_t crc, const char *symbol)
2428 {
2429         struct kmod_module_version *mv;
2430         size_t symbollen = strlen(symbol) + 1;
2431
2432         mv = malloc(sizeof(struct kmod_module_version) + symbollen);
2433         if (mv == NULL)
2434                 return NULL;
2435
2436         mv->crc = crc;
2437         memcpy(mv->symbol, symbol, symbollen);
2438         return mv;
2439 }
2440
2441 static void kmod_module_version_free(struct kmod_module_version *version)
2442 {
2443         free(version);
2444 }
2445
2446 /**
2447  * kmod_module_get_versions:
2448  * @mod: kmod module
2449  * @list: where to return list of module versions. Use
2450  *        kmod_module_version_get_symbol() and
2451  *        kmod_module_version_get_crc(). Release this list with
2452  *        kmod_module_versions_free_list()
2453  *
2454  * Get a list of entries in ELF section "__versions".
2455  *
2456  * After use, free the @list by calling kmod_module_versions_free_list().
2457  *
2458  * Returns: 0 on success or < 0 otherwise.
2459  */
2460 KMOD_EXPORT int kmod_module_get_versions(const struct kmod_module *mod, struct kmod_list **list)
2461 {
2462         struct kmod_elf *elf;
2463         struct kmod_modversion *versions;
2464         int i, count, ret = 0;
2465
2466         if (mod == NULL || list == NULL)
2467                 return -ENOENT;
2468
2469         assert(*list == NULL);
2470
2471         elf = kmod_module_get_elf(mod);
2472         if (elf == NULL)
2473                 return -errno;
2474
2475         count = kmod_elf_get_modversions(elf, &versions);
2476         if (count < 0)
2477                 return count;
2478
2479         for (i = 0; i < count; i++) {
2480                 struct kmod_module_version *mv;
2481                 struct kmod_list *n;
2482
2483                 mv = kmod_module_versions_new(versions[i].crc, versions[i].symbol);
2484                 if (mv == NULL) {
2485                         ret = -errno;
2486                         kmod_module_versions_free_list(*list);
2487                         *list = NULL;
2488                         goto list_error;
2489                 }
2490
2491                 n = kmod_list_append(*list, mv);
2492                 if (n != NULL)
2493                         *list = n;
2494                 else {
2495                         kmod_module_version_free(mv);
2496                         kmod_module_versions_free_list(*list);
2497                         *list = NULL;
2498                         ret = -ENOMEM;
2499                         goto list_error;
2500                 }
2501         }
2502         ret = count;
2503
2504 list_error:
2505         free(versions);
2506         return ret;
2507 }
2508
2509 /**
2510  * kmod_module_version_get_symbol:
2511  * @entry: a list entry representing a kmod module versions
2512  *
2513  * Get the symbol of a kmod module versions.
2514  *
2515  * Returns: the symbol of this kmod module versions on success or NULL
2516  * on failure. The string is owned by the versions, do not free it.
2517  */
2518 KMOD_EXPORT const char *kmod_module_version_get_symbol(const struct kmod_list *entry)
2519 {
2520         struct kmod_module_version *version;
2521
2522         if (entry == NULL || entry->data == NULL)
2523                 return NULL;
2524
2525         version = entry->data;
2526         return version->symbol;
2527 }
2528
2529 /**
2530  * kmod_module_version_get_crc:
2531  * @entry: a list entry representing a kmod module version
2532  *
2533  * Get the crc of a kmod module version.
2534  *
2535  * Returns: the crc of this kmod module version if available, otherwise default to 0.
2536  */
2537 KMOD_EXPORT uint64_t kmod_module_version_get_crc(const struct kmod_list *entry)
2538 {
2539         struct kmod_module_version *version;
2540
2541         if (entry == NULL || entry->data == NULL)
2542                 return 0;
2543
2544         version = entry->data;
2545         return version->crc;
2546 }
2547
2548 /**
2549  * kmod_module_versions_free_list:
2550  * @list: kmod module versions list
2551  *
2552  * Release the resources taken by @list
2553  */
2554 KMOD_EXPORT void kmod_module_versions_free_list(struct kmod_list *list)
2555 {
2556         while (list) {
2557                 kmod_module_version_free(list->data);
2558                 list = kmod_list_remove(list);
2559         }
2560 }
2561
2562 struct kmod_module_symbol {
2563         uint64_t crc;
2564         char symbol[];
2565 };
2566
2567 static struct kmod_module_symbol *kmod_module_symbols_new(uint64_t crc, const char *symbol)
2568 {
2569         struct kmod_module_symbol *mv;
2570         size_t symbollen = strlen(symbol) + 1;
2571
2572         mv = malloc(sizeof(struct kmod_module_symbol) + symbollen);
2573         if (mv == NULL)
2574                 return NULL;
2575
2576         mv->crc = crc;
2577         memcpy(mv->symbol, symbol, symbollen);
2578         return mv;
2579 }
2580
2581 static void kmod_module_symbol_free(struct kmod_module_symbol *symbol)
2582 {
2583         free(symbol);
2584 }
2585
2586 /**
2587  * kmod_module_get_symbols:
2588  * @mod: kmod module
2589  * @list: where to return list of module symbols. Use
2590  *        kmod_module_symbol_get_symbol() and
2591  *        kmod_module_symbol_get_crc(). Release this list with
2592  *        kmod_module_symbols_free_list()
2593  *
2594  * Get a list of entries in ELF section ".symtab" or "__ksymtab_strings".
2595  *
2596  * After use, free the @list by calling kmod_module_symbols_free_list().
2597  *
2598  * Returns: 0 on success or < 0 otherwise.
2599  */
2600 KMOD_EXPORT int kmod_module_get_symbols(const struct kmod_module *mod, struct kmod_list **list)
2601 {
2602         struct kmod_elf *elf;
2603         struct kmod_modversion *symbols;
2604         int i, count, ret = 0;
2605
2606         if (mod == NULL || list == NULL)
2607                 return -ENOENT;
2608
2609         assert(*list == NULL);
2610
2611         elf = kmod_module_get_elf(mod);
2612         if (elf == NULL)
2613                 return -errno;
2614
2615         count = kmod_elf_get_symbols(elf, &symbols);
2616         if (count < 0)
2617                 return count;
2618
2619         for (i = 0; i < count; i++) {
2620                 struct kmod_module_symbol *mv;
2621                 struct kmod_list *n;
2622
2623                 mv = kmod_module_symbols_new(symbols[i].crc, symbols[i].symbol);
2624                 if (mv == NULL) {
2625                         ret = -errno;
2626                         kmod_module_symbols_free_list(*list);
2627                         *list = NULL;
2628                         goto list_error;
2629                 }
2630
2631                 n = kmod_list_append(*list, mv);
2632                 if (n != NULL)
2633                         *list = n;
2634                 else {
2635                         kmod_module_symbol_free(mv);
2636                         kmod_module_symbols_free_list(*list);
2637                         *list = NULL;
2638                         ret = -ENOMEM;
2639                         goto list_error;
2640                 }
2641         }
2642         ret = count;
2643
2644 list_error:
2645         free(symbols);
2646         return ret;
2647 }
2648
2649 /**
2650  * kmod_module_symbol_get_symbol:
2651  * @entry: a list entry representing a kmod module symbols
2652  *
2653  * Get the symbol of a kmod module symbols.
2654  *
2655  * Returns: the symbol of this kmod module symbols on success or NULL
2656  * on failure. The string is owned by the symbols, do not free it.
2657  */
2658 KMOD_EXPORT const char *kmod_module_symbol_get_symbol(const struct kmod_list *entry)
2659 {
2660         struct kmod_module_symbol *symbol;
2661
2662         if (entry == NULL || entry->data == NULL)
2663                 return NULL;
2664
2665         symbol = entry->data;
2666         return symbol->symbol;
2667 }
2668
2669 /**
2670  * kmod_module_symbol_get_crc:
2671  * @entry: a list entry representing a kmod module symbol
2672  *
2673  * Get the crc of a kmod module symbol.
2674  *
2675  * Returns: the crc of this kmod module symbol if available, otherwise default to 0.
2676  */
2677 KMOD_EXPORT uint64_t kmod_module_symbol_get_crc(const struct kmod_list *entry)
2678 {
2679         struct kmod_module_symbol *symbol;
2680
2681         if (entry == NULL || entry->data == NULL)
2682                 return 0;
2683
2684         symbol = entry->data;
2685         return symbol->crc;
2686 }
2687
2688 /**
2689  * kmod_module_symbols_free_list:
2690  * @list: kmod module symbols list
2691  *
2692  * Release the resources taken by @list
2693  */
2694 KMOD_EXPORT void kmod_module_symbols_free_list(struct kmod_list *list)
2695 {
2696         while (list) {
2697                 kmod_module_symbol_free(list->data);
2698                 list = kmod_list_remove(list);
2699         }
2700 }
2701
2702 struct kmod_module_dependency_symbol {
2703         uint64_t crc;
2704         uint8_t bind;
2705         char symbol[];
2706 };
2707
2708 static struct kmod_module_dependency_symbol *kmod_module_dependency_symbols_new(uint64_t crc, uint8_t bind, const char *symbol)
2709 {
2710         struct kmod_module_dependency_symbol *mv;
2711         size_t symbollen = strlen(symbol) + 1;
2712
2713         mv = malloc(sizeof(struct kmod_module_dependency_symbol) + symbollen);
2714         if (mv == NULL)
2715                 return NULL;
2716
2717         mv->crc = crc;
2718         mv->bind = bind;
2719         memcpy(mv->symbol, symbol, symbollen);
2720         return mv;
2721 }
2722
2723 static void kmod_module_dependency_symbol_free(struct kmod_module_dependency_symbol *dependency_symbol)
2724 {
2725         free(dependency_symbol);
2726 }
2727
2728 /**
2729  * kmod_module_get_dependency_symbols:
2730  * @mod: kmod module
2731  * @list: where to return list of module dependency_symbols. Use
2732  *        kmod_module_dependency_symbol_get_symbol() and
2733  *        kmod_module_dependency_symbol_get_crc(). Release this list with
2734  *        kmod_module_dependency_symbols_free_list()
2735  *
2736  * Get a list of entries in ELF section ".symtab" or "__ksymtab_strings".
2737  *
2738  * After use, free the @list by calling
2739  * kmod_module_dependency_symbols_free_list().
2740  *
2741  * Returns: 0 on success or < 0 otherwise.
2742  */
2743 KMOD_EXPORT int kmod_module_get_dependency_symbols(const struct kmod_module *mod, struct kmod_list **list)
2744 {
2745         struct kmod_elf *elf;
2746         struct kmod_modversion *symbols;
2747         int i, count, ret = 0;
2748
2749         if (mod == NULL || list == NULL)
2750                 return -ENOENT;
2751
2752         assert(*list == NULL);
2753
2754         elf = kmod_module_get_elf(mod);
2755         if (elf == NULL)
2756                 return -errno;
2757
2758         count = kmod_elf_get_dependency_symbols(elf, &symbols);
2759         if (count < 0)
2760                 return count;
2761
2762         for (i = 0; i < count; i++) {
2763                 struct kmod_module_dependency_symbol *mv;
2764                 struct kmod_list *n;
2765
2766                 mv = kmod_module_dependency_symbols_new(symbols[i].crc,
2767                                                         symbols[i].bind,
2768                                                         symbols[i].symbol);
2769                 if (mv == NULL) {
2770                         ret = -errno;
2771                         kmod_module_dependency_symbols_free_list(*list);
2772                         *list = NULL;
2773                         goto list_error;
2774                 }
2775
2776                 n = kmod_list_append(*list, mv);
2777                 if (n != NULL)
2778                         *list = n;
2779                 else {
2780                         kmod_module_dependency_symbol_free(mv);
2781                         kmod_module_dependency_symbols_free_list(*list);
2782                         *list = NULL;
2783                         ret = -ENOMEM;
2784                         goto list_error;
2785                 }
2786         }
2787         ret = count;
2788
2789 list_error:
2790         free(symbols);
2791         return ret;
2792 }
2793
2794 /**
2795  * kmod_module_dependency_symbol_get_symbol:
2796  * @entry: a list entry representing a kmod module dependency_symbols
2797  *
2798  * Get the dependency symbol of a kmod module
2799  *
2800  * Returns: the symbol of this kmod module dependency_symbols on success or NULL
2801  * on failure. The string is owned by the dependency_symbols, do not free it.
2802  */
2803 KMOD_EXPORT const char *kmod_module_dependency_symbol_get_symbol(const struct kmod_list *entry)
2804 {
2805         struct kmod_module_dependency_symbol *dependency_symbol;
2806
2807         if (entry == NULL || entry->data == NULL)
2808                 return NULL;
2809
2810         dependency_symbol = entry->data;
2811         return dependency_symbol->symbol;
2812 }
2813
2814 /**
2815  * kmod_module_dependency_symbol_get_crc:
2816  * @entry: a list entry representing a kmod module dependency_symbol
2817  *
2818  * Get the crc of a kmod module dependency_symbol.
2819  *
2820  * Returns: the crc of this kmod module dependency_symbol if available, otherwise default to 0.
2821  */
2822 KMOD_EXPORT uint64_t kmod_module_dependency_symbol_get_crc(const struct kmod_list *entry)
2823 {
2824         struct kmod_module_dependency_symbol *dependency_symbol;
2825
2826         if (entry == NULL || entry->data == NULL)
2827                 return 0;
2828
2829         dependency_symbol = entry->data;
2830         return dependency_symbol->crc;
2831 }
2832
2833 /**
2834  * kmod_module_dependency_symbol_get_bind:
2835  * @entry: a list entry representing a kmod module dependency_symbol
2836  *
2837  * Get the bind type of a kmod module dependency_symbol.
2838  *
2839  * Returns: the bind of this kmod module dependency_symbol on success
2840  * or < 0 on failure.
2841  */
2842 KMOD_EXPORT int kmod_module_dependency_symbol_get_bind(const struct kmod_list *entry)
2843 {
2844         struct kmod_module_dependency_symbol *dependency_symbol;
2845
2846         if (entry == NULL || entry->data == NULL)
2847                 return 0;
2848
2849         dependency_symbol = entry->data;
2850         return dependency_symbol->bind;
2851 }
2852
2853 /**
2854  * kmod_module_dependency_symbols_free_list:
2855  * @list: kmod module dependency_symbols list
2856  *
2857  * Release the resources taken by @list
2858  */
2859 KMOD_EXPORT void kmod_module_dependency_symbols_free_list(struct kmod_list *list)
2860 {
2861         while (list) {
2862                 kmod_module_dependency_symbol_free(list->data);
2863                 list = kmod_list_remove(list);
2864         }
2865 }