src/core/kmod-setup.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <ftw.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24
  25 #include "alloc-util.h"
  26 #include "bus-util.h"
  27 #include "capability-util.h"
  28 #include "fileio.h"
  29 #include "kmod-setup.h"
  30 #include "macro.h"
  31 #include "string-util.h"
  32
  33 #if HAVE_KMOD
  34 #include <libkmod.h>
  35 #include "module-util.h"
  36
  37 static void systemd_kmod_log(
  38                 void *data,
  39                 int priority,
  40                 const char *file, int line,
  41                 const char *fn,
  42                 const char *format,
  43                 va_list args) {
  44
  45         /* library logging is enabled at debug only */
  46         DISABLE_WARNING_FORMAT_NONLITERAL;
  47         log_internalv(LOG_DEBUG, 0, file, line, fn, format, args);
  48         REENABLE_WARNING;
  49 }
  50
  51 static int has_virtio_rng_nftw_cb(
  52                 const char *fpath,
  53                 const struct stat *sb,
  54                 int tflag,
  55                 struct FTW *ftwbuf) {
  56
  57         _cleanup_free_ char *alias = NULL;
  58         int r;
  59
  60         if ((FTW_D == tflag) && (ftwbuf->level > 2))
  61                 return FTW_SKIP_SUBTREE;
  62
  63         if (FTW_F != tflag)
  64                 return FTW_CONTINUE;
  65
  66         if (!endswith(fpath, "/modalias"))
  67                 return FTW_CONTINUE;
  68
  69         r = read_one_line_file(fpath, &alias);
  70         if (r < 0)
  71                 return FTW_SKIP_SIBLINGS;
  72
  73         if (startswith(alias, "pci:v00001AF4d00001005"))
  74                 return FTW_STOP;
  75
  76         if (startswith(alias, "pci:v00001AF4d00001044"))
  77                 return FTW_STOP;
  78
  79         return FTW_SKIP_SIBLINGS;
  80 }
  81
  82 static bool has_virtio_rng(void) {
  83         return (nftw("/sys/devices/pci0000:00", has_virtio_rng_nftw_cb, 64, FTW_MOUNT|FTW_PHYS|FTW_ACTIONRETVAL) == FTW_STOP);
  84 }
  85 #endif
  86
  87 int kmod_setup(void) {
  88 #if HAVE_KMOD
  89
  90         static const struct {
  91                 const char *module;
  92                 const char *path;
  93                 bool warn_if_unavailable:1;
  94                 bool warn_if_module:1;
  95                 bool (*condition_fn)(void);
  96         } kmod_table[] = {
  97                 /* auto-loading on use doesn't work before udev is up */
  98                 { "autofs4",   "/sys/class/misc/autofs",    true,   false,   NULL      },
  99
 100                 /* early configure of ::1 on the loopback device */
 101                 { "ipv6",      "/sys/module/ipv6",          false,  true,    NULL      },
 102
 103                 /* this should never be a module */
 104                 { "unix",      "/proc/net/unix",            true,   true,    NULL      },
 105
 106 #if HAVE_LIBIPTC
 107                 /* netfilter is needed by networkd, nspawn among others, and cannot be autoloaded */
 108                 { "ip_tables", "/proc/net/ip_tables_names", false,  false,   NULL      },
 109 #endif
 110                 /* virtio_rng would be loaded by udev later, but real entropy might be needed very early */
 111                 { "virtio_rng", NULL,                       false,  false,   has_virtio_rng },
 112         };
 113         _cleanup_(kmod_unrefp) struct kmod_ctx *ctx = NULL;
 114         unsigned int i;
 115         int r;
 116
 117         if (have_effective_cap(CAP_SYS_MODULE) == 0)
 118                 return 0;
 119
 120         for (i = 0; i < ELEMENTSOF(kmod_table); i++) {
 121                 _cleanup_(kmod_module_unrefp) struct kmod_module *mod = NULL;
 122
 123                 if (kmod_table[i].path && access(kmod_table[i].path, F_OK) >= 0)
 124                         continue;
 125
 126                 if (kmod_table[i].condition_fn && !kmod_table[i].condition_fn())
 127                         continue;
 128
 129                 if (kmod_table[i].warn_if_module)
 130                         log_debug("Your kernel apparently lacks built-in %s support. Might be "
 131                                   "a good idea to compile it in. We'll now try to work around "
 132                                   "this by loading the module...", kmod_table[i].module);
 133
 134                 if (!ctx) {
 135                         ctx = kmod_new(NULL, NULL);
 136                         if (!ctx)
 137                                 return log_oom();
 138
 139                         kmod_set_log_fn(ctx, systemd_kmod_log, NULL);
 140                         kmod_load_resources(ctx);
 141                 }
 142
 143                 r = kmod_module_new_from_name(ctx, kmod_table[i].module, &mod);
 144                 if (r < 0) {
 145                         log_error("Failed to lookup module '%s'", kmod_table[i].module);
 146                         continue;
 147                 }
 148
 149                 r = kmod_module_probe_insert_module(mod, KMOD_PROBE_APPLY_BLACKLIST, NULL, NULL, NULL, NULL);
 150                 if (r == 0)
 151                         log_debug("Inserted module '%s'", kmod_module_get_name(mod));
 152                 else if (r == KMOD_PROBE_APPLY_BLACKLIST)
 153                         log_info("Module '%s' is blacklisted", kmod_module_get_name(mod));
 154                 else {
 155                         bool print_warning = kmod_table[i].warn_if_unavailable || (r < 0 && r != -ENOENT);
 156
 157                         log_full_errno(print_warning ? LOG_WARNING : LOG_DEBUG, r,
 158                                        "Failed to insert module '%s': %m", kmod_module_get_name(mod));
 159                 }
 160         }
 161
 162 #endif
 163         return 0;
 164 }