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 load_module(struct kmod_ctx *ctx, const char *m) {
  63         const int probe_flags = KMOD_PROBE_APPLY_BLACKLIST;
  64         struct kmod_list *itr;
  65         _cleanup_(kmod_module_unref_listp) struct kmod_list *modlist = NULL;
  66         int r = 0;
  67
  68         log_debug("load: %s", m);
  69
  70         r = kmod_module_new_from_lookup(ctx, m, &modlist);
  71         if (r < 0)
  72                 return log_error_errno(r, "Failed to lookup alias '%s': %m", m);
  73
  74         if (!modlist) {
  75                 log_error("Failed to find module '%s'", m);
  76                 return -ENOENT;
  77         }
  78
  79         kmod_list_foreach(itr, modlist) {
  80                 _cleanup_(kmod_module_unrefp) struct kmod_module *mod = NULL;
  81                 int state, err;
  82
  83                 mod = kmod_module_get_module(itr);
  84                 state = kmod_module_get_initstate(mod);
  85
  86                 switch (state) {
  87                 case KMOD_MODULE_BUILTIN:
  88                         log_info("Module '%s' is builtin", kmod_module_get_name(mod));
  89                         break;
  90
  91                 case KMOD_MODULE_LIVE:
  92                         log_debug("Module '%s' is already loaded", kmod_module_get_name(mod));
  93                         break;
  94
  95                 default:
  96                         err = kmod_module_probe_insert_module(mod, probe_flags,
  97                                                               NULL, NULL, NULL, NULL);
  98
  99                         if (err == 0)
 100                                 log_info("Inserted module '%s'", kmod_module_get_name(mod));
 101                         else if (err == KMOD_PROBE_APPLY_BLACKLIST)
 102                                 log_info("Module '%s' is blacklisted", kmod_module_get_name(mod));
 103                         else {
 104                                 assert(err < 0);
 105
 106                                 log_full_errno(err == ENODEV ? LOG_NOTICE :
 107                                                err == ENOENT ? LOG_WARNING :
 108                                                                LOG_ERR,
 109                                                err,
 110                                                "Failed to insert '%s': %m",
 111                                                kmod_module_get_name(mod));
 112                                 if (!IN_SET(err, ENODEV, ENOENT))
 113                                         r = err;
 114                         }
 115                 }
 116         }
 117
 118         return r;
 119 }
 120
 121 static int apply_file(struct kmod_ctx *ctx, const char *path, bool ignore_enoent) {
 122         _cleanup_fclose_ FILE *f = NULL;
 123         int r;
 124
 125         assert(ctx);
 126         assert(path);
 127
 128         r = search_and_fopen_nulstr(path, "re", NULL, conf_file_dirs, &f);
 129         if (r < 0) {
 130                 if (ignore_enoent && r == -ENOENT)
 131                         return 0;
 132
 133                 return log_error_errno(r, "Failed to open %s, ignoring: %m", path);
 134         }
 135
 136         log_debug("apply: %s", path);
 137         for (;;) {
 138                 char line[LINE_MAX], *l;
 139                 int k;
 140
 141                 if (!fgets(line, sizeof(line), f)) {
 142                         if (feof(f))
 143                                 break;
 144
 145                         return log_error_errno(errno, "Failed to read file '%s', ignoring: %m", path);
 146                 }
 147
 148                 l = strstrip(line);
 149                 if (!*l)
 150                         continue;
 151                 if (strchr(COMMENTS "\n", *l))
 152                         continue;
 153
 154                 k = load_module(ctx, l);
 155                 if (k < 0 && r == 0)
 156                         r = k;
 157         }
 158
 159         return r;
 160 }
 161
 162 static void help(void) {
 163         printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
 164                "Loads statically configured kernel modules.\n\n"
 165                "  -h --help             Show this help\n"
 166                "     --version          Show package version\n",
 167                program_invocation_short_name);
 168 }
 169
 170 static int parse_argv(int argc, char *argv[]) {
 171
 172         enum {
 173                 ARG_VERSION = 0x100,
 174         };
 175
 176         static const struct option options[] = {
 177                 { "help",      no_argument,       NULL, 'h'           },
 178                 { "version",   no_argument,       NULL, ARG_VERSION   },
 179                 {}
 180         };
 181
 182         int c;
 183
 184         assert(argc >= 0);
 185         assert(argv);
 186
 187         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 188
 189                 switch (c) {
 190
 191                 case 'h':
 192                         help();
 193                         return 0;
 194
 195                 case ARG_VERSION:
 196                         return version();
 197
 198                 case '?':
 199                         return -EINVAL;
 200
 201                 default:
 202                         assert_not_reached("Unhandled option");
 203                 }
 204
 205         return 1;
 206 }
 207
 208 int main(int argc, char *argv[]) {
 209         int r, k;
 210         _cleanup_(kmod_unrefp) struct kmod_ctx *ctx = NULL;
 211
 212         r = parse_argv(argc, argv);
 213         if (r <= 0)
 214                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 215
 216         log_set_target(LOG_TARGET_AUTO);
 217         log_parse_environment();
 218         log_open();
 219
 220         umask(0022);
 221
 222         r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
 223         if (r < 0)
 224                 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
 225
 226         ctx = kmod_new(NULL, NULL);
 227         if (!ctx) {
 228                 log_error("Failed to allocate memory for kmod.");
 229                 goto finish;
 230         }
 231
 232         kmod_load_resources(ctx);
 233         kmod_set_log_fn(ctx, systemd_kmod_log, NULL);
 234
 235         r = 0;
 236
 237         if (argc > optind) {
 238                 int i;
 239
 240                 for (i = optind; i < argc; i++) {
 241                         k = apply_file(ctx, argv[i], false);
 242                         if (k < 0 && r == 0)
 243                                 r = k;
 244                 }
 245
 246         } else {
 247                 _cleanup_strv_free_ char **files = NULL;
 248                 char **fn, **i;
 249
 250                 STRV_FOREACH(i, arg_proc_cmdline_modules) {
 251                         k = load_module(ctx, *i);
 252                         if (k < 0 && r == 0)
 253                                 r = k;
 254                 }
 255
 256                 k = conf_files_list_nulstr(&files, ".conf", NULL, 0, conf_file_dirs);
 257                 if (k < 0) {
 258                         log_error_errno(k, "Failed to enumerate modules-load.d files: %m");
 259                         if (r == 0)
 260                                 r = k;
 261                         goto finish;
 262                 }
 263
 264                 STRV_FOREACH(fn, files) {
 265                         k = apply_file(ctx, *fn, true);
 266                         if (k < 0 && r == 0)
 267                                 r = k;
 268                 }
 269         }
 270
 271 finish:
 272         strv_free(arg_proc_cmdline_modules);
 273
 274         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 275 }