src/core/kmod-setup.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <ftw.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23
  24 #ifdef HAVE_KMOD
  25 #include <libkmod.h>
  26 #endif
  27
  28 #include "alloc-util.h"
  29 #include "bus-util.h"
  30 #include "capability-util.h"
  31 #include "fileio.h"
  32 #include "kmod-setup.h"
  33 #include "macro.h"
  34 #include "string-util.h"
  35
  36 #ifdef HAVE_KMOD
  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 #endif
  51
  52 static int has_virtio_rng_nftw_cb(
  53                 const char *fpath,
  54                 const struct stat *sb,
  55                 int tflag,
  56                 struct FTW *ftwbuf) {
  57
  58         _cleanup_free_ char *alias = NULL;
  59         int r;
  60
  61         if ((FTW_D == tflag) && (ftwbuf->level > 2))
  62                 return FTW_SKIP_SUBTREE;
  63
  64         if (FTW_F != tflag)
  65                 return FTW_CONTINUE;
  66
  67         if (!endswith(fpath, "/modalias"))
  68                 return FTW_CONTINUE;
  69
  70         r = read_one_line_file(fpath, &alias);
  71         if (r < 0)
  72                 return FTW_SKIP_SIBLINGS;
  73
  74         if (startswith(alias, "pci:v00001AF4d00001005"))
  75                 return FTW_STOP;
  76
  77         if (startswith(alias, "pci:v00001AF4d00001044"))
  78                 return FTW_STOP;
  79
  80         return FTW_SKIP_SIBLINGS;
  81 }
  82
  83 static bool has_virtio_rng(void) {
  84         return (nftw("/sys/devices/pci0000:00", has_virtio_rng_nftw_cb, 64, FTW_MOUNT|FTW_PHYS|FTW_ACTIONRETVAL) == FTW_STOP);
  85 }
  86
  87 int kmod_setup(void) {
  88 #ifdef 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 #ifdef 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         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                 struct kmod_module *mod;
 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                 kmod_module_unref(mod);
 162         }
 163
 164         if (ctx)
 165                 kmod_unref(ctx);
 166
 167 #endif
 168         return 0;
 169 }