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