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