src/modules-load/modules-load.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <getopt.h>
   5 #include <libkmod.h>
   6 #include <limits.h>
   7 #include <string.h>
   8 #include <sys/stat.h>
   9
  10 #include "conf-files.h"
  11 #include "def.h"
  12 #include "fd-util.h"
  13 #include "fileio.h"
  14 #include "log.h"
  15 #include "module-util.h"
  16 #include "proc-cmdline.h"
  17 #include "string-util.h"
  18 #include "strv.h"
  19 #include "util.h"
  20
  21 static char **arg_proc_cmdline_modules = NULL;
  22
  23 static const char conf_file_dirs[] = CONF_PATHS_NULSTR("modules-load.d");
  24
  25 static void systemd_kmod_log(void *data, int priority, const char *file, int line,
  26                              const char *fn, const char *format, va_list args) {
  27
  28         DISABLE_WARNING_FORMAT_NONLITERAL;
  29         log_internalv(priority, 0, file, line, fn, format, args);
  30         REENABLE_WARNING;
  31 }
  32
  33 static int add_modules(const char *p) {
  34         _cleanup_strv_free_ char **k = NULL;
  35
  36         k = strv_split(p, ",");
  37         if (!k)
  38                 return log_oom();
  39
  40         if (strv_extend_strv(&arg_proc_cmdline_modules, k, true) < 0)
  41                 return log_oom();
  42
  43         return 0;
  44 }
  45
  46 static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
  47         int r;
  48
  49         if (proc_cmdline_key_streq(key, "modules_load")) {
  50
  51                 if (proc_cmdline_value_missing(key, value))
  52                         return 0;
  53
  54                 r = add_modules(value);
  55                 if (r < 0)
  56                         return r;
  57         }
  58
  59         return 0;
  60 }
  61
  62 static int apply_file(struct kmod_ctx *ctx, const char *path, bool ignore_enoent) {
  63         _cleanup_fclose_ FILE *f = NULL;
  64         int r;
  65
  66         assert(ctx);
  67         assert(path);
  68
  69         r = search_and_fopen_nulstr(path, "re", NULL, conf_file_dirs, &f);
  70         if (r < 0) {
  71                 if (ignore_enoent && r == -ENOENT)
  72                         return 0;
  73
  74                 return log_error_errno(r, "Failed to open %s, ignoring: %m", path);
  75         }
  76
  77         log_debug("apply: %s", path);
  78         for (;;) {
  79                 char line[LINE_MAX], *l;
  80                 int k;
  81
  82                 if (!fgets(line, sizeof(line), f)) {
  83                         if (feof(f))
  84                                 break;
  85
  86                         return log_error_errno(errno, "Failed to read file '%s', ignoring: %m", path);
  87                 }
  88
  89                 l = strstrip(line);
  90                 if (!*l)
  91                         continue;
  92                 if (strchr(COMMENTS "\n", *l))
  93                         continue;
  94
  95                 k = module_load_and_warn(ctx, l);
  96                 if (k < 0 && r == 0)
  97                         r = k;
  98         }
  99
 100         return r;
 101 }
 102
 103 static void help(void) {
 104         printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
 105                "Loads statically configured kernel modules.\n\n"
 106                "  -h --help             Show this help\n"
 107                "     --version          Show package version\n",
 108                program_invocation_short_name);
 109 }
 110
 111 static int parse_argv(int argc, char *argv[]) {
 112
 113         enum {
 114                 ARG_VERSION = 0x100,
 115         };
 116
 117         static const struct option options[] = {
 118                 { "help",      no_argument,       NULL, 'h'           },
 119                 { "version",   no_argument,       NULL, ARG_VERSION   },
 120                 {}
 121         };
 122
 123         int c;
 124
 125         assert(argc >= 0);
 126         assert(argv);
 127
 128         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 129
 130                 switch (c) {
 131
 132                 case 'h':
 133                         help();
 134                         return 0;
 135
 136                 case ARG_VERSION:
 137                         return version();
 138
 139                 case '?':
 140                         return -EINVAL;
 141
 142                 default:
 143                         assert_not_reached("Unhandled option");
 144                 }
 145
 146         return 1;
 147 }
 148
 149 int main(int argc, char *argv[]) {
 150         int r, k;
 151         _cleanup_(kmod_unrefp) struct kmod_ctx *ctx = NULL;
 152
 153         r = parse_argv(argc, argv);
 154         if (r <= 0)
 155                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 156
 157         log_set_target(LOG_TARGET_AUTO);
 158         log_parse_environment();
 159         log_open();
 160
 161         umask(0022);
 162
 163         r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
 164         if (r < 0)
 165                 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
 166
 167         ctx = kmod_new(NULL, NULL);
 168         if (!ctx) {
 169                 log_error("Failed to allocate memory for kmod.");
 170                 goto finish;
 171         }
 172
 173         kmod_load_resources(ctx);
 174         kmod_set_log_fn(ctx, systemd_kmod_log, NULL);
 175
 176         r = 0;
 177
 178         if (argc > optind) {
 179                 int i;
 180
 181                 for (i = optind; i < argc; i++) {
 182                         k = apply_file(ctx, argv[i], false);
 183                         if (k < 0 && r == 0)
 184                                 r = k;
 185                 }
 186
 187         } else {
 188                 _cleanup_strv_free_ char **files = NULL;
 189                 char **fn, **i;
 190
 191                 STRV_FOREACH(i, arg_proc_cmdline_modules) {
 192                         k = module_load_and_warn(ctx, *i);
 193                         if (k < 0 && r == 0)
 194                                 r = k;
 195                 }
 196
 197                 k = conf_files_list_nulstr(&files, ".conf", NULL, 0, conf_file_dirs);
 198                 if (k < 0) {
 199                         log_error_errno(k, "Failed to enumerate modules-load.d files: %m");
 200                         if (r == 0)
 201                                 r = k;
 202                         goto finish;
 203                 }
 204
 205                 STRV_FOREACH(fn, files) {
 206                         k = apply_file(ctx, *fn, true);
 207                         if (k < 0 && r == 0)
 208                                 r = k;
 209                 }
 210         }
 211
 212 finish:
 213         strv_free(arg_proc_cmdline_modules);
 214
 215         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 216 }