modules-load.c 4.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <limits.h>
#include <dirent.h>

#include "log.h"
#include "util.h"
#include "strv.h"

34
/* This reads all module names listed in /etc/modules.d/?*.conf and
35 36 37 38 39 40 41 42 43 44 45 46 47 48
 * loads them into the kernel. This follows roughly Debian's way to
 * handle modules, but uses a directory of fragments instead of a
 * single /etc/modules file. */

static int scandir_filter(const struct dirent *d) {
        assert(d);

        if (ignore_file(d->d_name))
                return 0;

        if (d->d_type != DT_REG &&
            d->d_type != DT_LNK)
                return 0;

49
        return endswith(d->d_name, ".conf");
50 51 52 53
}

int main(int argc, char *argv[]) {
        struct dirent **de = NULL;
54
        int r = EXIT_FAILURE, n, i;
55 56 57 58 59
        char **arguments = NULL;
        unsigned n_arguments = 0, n_allocated = 0;

        if (argc > 1) {
                log_error("This program takes no argument.");
60
                return EXIT_FAILURE;
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
        }

        log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
        log_parse_environment();
        log_open();

        if (!(arguments = strv_new("/sbin/modprobe", "-sab", "--", NULL))) {
                log_error("Failed to allocate string array");
                goto finish;
        }

        n_arguments = n_allocated = 3;

        if ((n = scandir("/etc/modules.d/", &de, scandir_filter, alphasort)) < 0) {

                if (errno == ENOENT)
77
                        r = EXIT_SUCCESS;
78 79 80 81 82 83
                else
                        log_error("Failed to enumerate /etc/modules.d/ files: %m");

                goto finish;
        }

84
        r = EXIT_SUCCESS;
85 86 87 88 89 90 91 92 93 94 95

        for (i = 0; i < n; i++) {
                int k;
                char *fn;
                FILE *f;

                k = asprintf(&fn, "/etc/modules.d/%s", de[i]->d_name);
                free(de[i]);

                if (k < 0) {
                        log_error("Failed to allocate file name.");
96
                        r = EXIT_FAILURE;
97 98 99 100 101 102 103 104
                        continue;
                }

                f = fopen(fn, "re");
                free(fn);

                if (!f) {
                        log_error("Failed to open %s: %m", fn);
105
                        r = EXIT_FAILURE;
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
                        continue;
                }

                for (;;) {
                        char line[LINE_MAX], *l, *t;

                        if (!(fgets(line, sizeof(line), f)))
                                break;

                        l = strstrip(line);
                        if (*l == '#' || *l == 0)
                                continue;

                        if (!(t = strdup(l))) {
                                log_error("Failed to allocate module name.");
                                continue;
                        }

                        if (n_arguments >= n_allocated) {
                                char **a;
                                unsigned m;

                                m = MAX(16U, n_arguments*2);

                                if (!(a = realloc(arguments, sizeof(char*) * (m+1)))) {
                                        log_error("Failed to increase module array size.");
                                        free(t);
133
                                        r = EXIT_FAILURE;
134 135 136 137 138 139 140 141 142 143 144
                                        continue;
                                }

                                arguments = a;
                                n_allocated = m;
                        }

                        arguments[n_arguments++] = t;
                }

                if (ferror(f)) {
145
                        r = EXIT_FAILURE;
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
                        log_error("Failed to read from file: %m");
                }

                fclose(f);
        }

        free(de);

finish:

        if (n_arguments > 3) {
                arguments[n_arguments] = NULL;
                execv("/sbin/modprobe", arguments);

                log_error("Failed to execute /sbin/modprobe: %m");
161
                r = EXIT_FAILURE;
162 163 164 165 166 167
        }

        strv_free(arguments);

        return r;
}