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