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 <string.h>
  24 #include <sys/stat.h>
  25 #include <limits.h>
  26 #include <getopt.h>
  27 #include <libkmod.h>
  28
  29 #include "log.h"
  30 #include "util.h"
  31 #include "strv.h"
  32 #include "conf-files.h"
  33 #include "build.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) < 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                         puts(PACKAGE_STRING);
 203                         puts(SYSTEMD_FEATURES);
 204                         return 0;
 205
 206                 case '?':
 207                         return -EINVAL;
 208
 209                 default:
 210                         assert_not_reached("Unhandled option");
 211                 }
 212
 213         return 1;
 214 }
 215
 216 int main(int argc, char *argv[]) {
 217         int r, k;
 218         struct kmod_ctx *ctx;
 219
 220         r = parse_argv(argc, argv);
 221         if (r <= 0)
 222                 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 223
 224         log_set_target(LOG_TARGET_AUTO);
 225         log_parse_environment();
 226         log_open();
 227
 228         umask(0022);
 229
 230         r = parse_proc_cmdline(parse_proc_cmdline_item);
 231         if (r < 0)
 232                 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
 233
 234         ctx = kmod_new(NULL, NULL);
 235         if (!ctx) {
 236                 log_error("Failed to allocate memory for kmod.");
 237                 goto finish;
 238         }
 239
 240         kmod_load_resources(ctx);
 241         kmod_set_log_fn(ctx, systemd_kmod_log, NULL);
 242
 243         r = 0;
 244
 245         if (argc > optind) {
 246                 int i;
 247
 248                 for (i = optind; i < argc; i++) {
 249                         k = apply_file(ctx, argv[i], false);
 250                         if (k < 0 && r == 0)
 251                                 r = k;
 252                 }
 253
 254         } else {
 255                 _cleanup_free_ char **files = NULL;
 256                 char **fn, **i;
 257
 258                 STRV_FOREACH(i, arg_proc_cmdline_modules) {
 259                         k = load_module(ctx, *i);
 260                         if (k < 0 && r == 0)
 261                                 r = k;
 262                 }
 263
 264                 k = conf_files_list_nulstr(&files, ".conf", NULL, conf_file_dirs);
 265                 if (k < 0) {
 266                         log_error_errno(k, "Failed to enumerate modules-load.d files: %m");
 267                         if (r == 0)
 268                                 r = k;
 269                         goto finish;
 270                 }
 271
 272                 STRV_FOREACH(fn, files) {
 273                         k = apply_file(ctx, *fn, true);
 274                         if (k < 0 && r == 0)
 275                                 r = k;
 276                 }
 277         }
 278
 279 finish:
 280         kmod_unref(ctx);
 281         strv_free(arg_proc_cmdline_modules);
 282
 283         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 284 }