src/modules-load/modules-load.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <limits.h>
  28 #include <dirent.h>
  29 #include <getopt.h>
  30 #include <libkmod.h>
  31
  32 #include "log.h"
  33 #include "util.h"
  34 #include "strv.h"
  35 #include "conf-files.h"
  36 #include "fileio.h"
  37 #include "build.h"
  38
  39 static char **arg_proc_cmdline_modules = NULL;
  40
  41 static const char conf_file_dirs[] =
  42         "/etc/modules-load.d\0"
  43         "/run/modules-load.d\0"
  44         "/usr/local/lib/modules-load.d\0"
  45         "/usr/lib/modules-load.d\0"
  46 #ifdef HAVE_SPLIT_USR
  47         "/lib/modules-load.d\0"
  48 #endif
  49         ;
  50
  51 #pragma GCC diagnostic push
  52 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
  53 static void systemd_kmod_log(void *data, int priority, const char *file, int line,
  54                              const char *fn, const char *format, va_list args) {
  55         log_metav(priority, file, line, fn, format, args);
  56 }
  57 #pragma GCC diagnostic pop
  58
  59 static int add_modules(const char *p) {
  60         char **t;
  61         _cleanup_strv_free_ char **k = NULL;
  62
  63         k = strv_split(p, ",");
  64         if (!k)
  65                 return log_oom();
  66
  67         t = strv_merge(arg_proc_cmdline_modules, k);
  68         if (!t)
  69                 return log_oom();
  70
  71         strv_free(arg_proc_cmdline_modules);
  72         arg_proc_cmdline_modules = t;
  73
  74         return 0;
  75 }
  76
  77 static int parse_proc_cmdline(void) {
  78         _cleanup_free_ char *line = NULL;
  79         char *w, *state;
  80         size_t l;
  81         int r;
  82
  83         r = proc_cmdline(&line);
  84         if (r < 0)
  85                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
  86         if (r <= 0)
  87                 return 0;
  88
  89         FOREACH_WORD_QUOTED(w, l, line, state) {
  90                 _cleanup_free_ char *word;
  91
  92                 word = strndup(w, l);
  93                 if (!word)
  94                         return log_oom();
  95
  96                 if (startswith(word, "modules-load=")) {
  97
  98                         r = add_modules(word + 13);
  99                         if (r < 0)
 100                                 return r;
 101
 102                 } else if (startswith(word, "rd.modules-load=")) {
 103
 104                         if (in_initrd()) {
 105                                 r = add_modules(word + 16);
 106                                 if (r < 0)
 107                                         return r;
 108                         }
 109
 110                 }
 111         }
 112
 113         return 0;
 114 }
 115
 116 static int load_module(struct kmod_ctx *ctx, const char *m) {
 117         const int probe_flags = KMOD_PROBE_APPLY_BLACKLIST;
 118         struct kmod_list *itr, *modlist = NULL;
 119         int r = 0;
 120
 121         log_debug("load: %s\n", m);
 122
 123         r = kmod_module_new_from_lookup(ctx, m, &modlist);
 124         if (r < 0) {
 125                 log_error("Failed to lookup alias '%s': %s", m, strerror(-r));
 126                 return r;
 127         }
 128
 129         if (!modlist) {
 130                 log_error("Failed to find module '%s'", m);
 131                 return -ENOENT;
 132         }
 133
 134         kmod_list_foreach(itr, modlist) {
 135                 struct kmod_module *mod;
 136                 int state, err;
 137
 138                 mod = kmod_module_get_module(itr);
 139                 state = kmod_module_get_initstate(mod);
 140
 141                 switch (state) {
 142                 case KMOD_MODULE_BUILTIN:
 143                         log_info("Module '%s' is builtin", kmod_module_get_name(mod));
 144                         break;
 145
 146                 case KMOD_MODULE_LIVE:
 147                         log_debug("Module '%s' is already loaded", kmod_module_get_name(mod));
 148                         break;
 149
 150                 default:
 151                         err = kmod_module_probe_insert_module(mod, probe_flags,
 152                                                               NULL, NULL, NULL, NULL);
 153
 154                         if (err == 0)
 155                                 log_info("Inserted module '%s'", kmod_module_get_name(mod));
 156                         else if (err == KMOD_PROBE_APPLY_BLACKLIST)
 157                                 log_info("Module '%s' is blacklisted", kmod_module_get_name(mod));
 158                         else {
 159                                 log_error("Failed to insert '%s': %s", kmod_module_get_name(mod),
 160                                           strerror(-err));
 161                                 r = err;
 162                         }
 163                 }
 164
 165                 kmod_module_unref(mod);
 166         }
 167
 168         kmod_module_unref_list(modlist);
 169
 170         return r;
 171 }
 172
 173 static int apply_file(struct kmod_ctx *ctx, const char *path, bool ignore_enoent) {
 174         _cleanup_fclose_ FILE *f = NULL;
 175         int r;
 176
 177         assert(ctx);
 178         assert(path);
 179
 180         r = search_and_fopen_nulstr(path, "re", conf_file_dirs, &f);
 181         if (r < 0) {
 182                 if (ignore_enoent && r == -ENOENT)
 183                         return 0;
 184
 185                 log_error("Failed to open %s, ignoring: %s", path, strerror(-r));
 186                 return r;
 187         }
 188
 189         log_debug("apply: %s\n", path);
 190         for (;;) {
 191                 char line[LINE_MAX], *l;
 192                 int k;
 193
 194                 if (!fgets(line, sizeof(line), f)) {
 195                         if (feof(f))
 196                                 break;
 197
 198                         log_error("Failed to read file '%s', ignoring: %m", path);
 199                         return -errno;
 200                 }
 201
 202                 l = strstrip(line);
 203                 if (!*l)
 204                         continue;
 205                 if (strchr(COMMENTS "\n", *l))
 206                         continue;
 207
 208                 k = load_module(ctx, l);
 209                 if (k < 0 && r == 0)
 210                         r = k;
 211         }
 212
 213         return r;
 214 }
 215
 216 static int help(void) {
 217
 218         printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
 219                "Loads statically configured kernel modules.\n\n"
 220                "  -h --help             Show this help\n"
 221                "     --version          Show package version\n",
 222                program_invocation_short_name);
 223
 224         return 0;
 225 }
 226
 227 static int parse_argv(int argc, char *argv[]) {
 228
 229         enum {
 230                 ARG_VERSION = 0x100,
 231         };
 232
 233         static const struct option options[] = {
 234                 { "help",      no_argument,       NULL, 'h'           },
 235                 { "version",   no_argument,       NULL, ARG_VERSION   },
 236                 {}
 237         };
 238
 239         int c;
 240
 241         assert(argc >= 0);
 242         assert(argv);
 243
 244         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) {
 245
 246                 switch (c) {
 247
 248                 case 'h':
 249                         return help();
 250
 251                 case ARG_VERSION:
 252                         puts(PACKAGE_STRING);
 253                         puts(SYSTEMD_FEATURES);
 254                         return 0;
 255
 256                 case '?':
 257                         return -EINVAL;
 258
 259                 default:
 260                         assert_not_reached("Unhandled option");
 261                 }
 262         }
 263
 264         return 1;
 265 }
 266
 267 int main(int argc, char *argv[]) {
 268         int r, k;
 269         struct kmod_ctx *ctx;
 270
 271         r = parse_argv(argc, argv);
 272         if (r <= 0)
 273                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 274
 275         log_set_target(LOG_TARGET_AUTO);
 276         log_parse_environment();
 277         log_open();
 278
 279         umask(0022);
 280
 281         if (parse_proc_cmdline() < 0)
 282                 return EXIT_FAILURE;
 283
 284         ctx = kmod_new(NULL, NULL);
 285         if (!ctx) {
 286                 log_error("Failed to allocate memory for kmod.");
 287                 goto finish;
 288         }
 289
 290         kmod_load_resources(ctx);
 291         kmod_set_log_fn(ctx, systemd_kmod_log, NULL);
 292
 293         r = 0;
 294
 295         if (argc > optind) {
 296                 int i;
 297
 298                 for (i = optind; i < argc; i++) {
 299                         k = apply_file(ctx, argv[i], false);
 300                         if (k < 0 && r == 0)
 301                                 r = k;
 302                 }
 303
 304         } else {
 305                 _cleanup_free_ char **files = NULL;
 306                 char **fn, **i;
 307
 308                 STRV_FOREACH(i, arg_proc_cmdline_modules) {
 309                         k = load_module(ctx, *i);
 310                         if (k < 0 && r == 0)
 311                                 r = k;
 312                 }
 313
 314                 r = conf_files_list_nulstr(&files, ".conf", NULL, conf_file_dirs);
 315                 if (r < 0) {
 316                         log_error("Failed to enumerate modules-load.d files: %s", strerror(-r));
 317                         goto finish;
 318                 }
 319
 320                 STRV_FOREACH(fn, files) {
 321                         k = apply_file(ctx, *fn, true);
 322                         if (k < 0 && r == 0)
 323                                 r = k;
 324                 }
 325         }
 326
 327 finish:
 328         kmod_unref(ctx);
 329         strv_free(arg_proc_cmdline_modules);
 330
 331         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 332 }