src/modules-load/modules-load.c

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