modules-load.c 5.04 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-load.d/?*.conf and
35 36 37 38 39 40 41 42 43 44 45
 * 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 &&
46 47
            d->d_type != DT_LNK &&
            d->d_type != DT_UNKNOWN)
48 49
                return 0;

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

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

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

        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;

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

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

                goto finish;
        }

85
        r = EXIT_SUCCESS;
86 87 88 89 90 91

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

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

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

                f = fopen(fn, "re");

                if (!f) {
Lennart Poettering's avatar
Lennart Poettering committed
104 105
                        if (errno == ENOENT) {
                                free(fn);
106
                                continue;
Lennart Poettering's avatar
Lennart Poettering committed
107
                        }
108

109
                        log_error("Failed to open %s: %m", fn);
Lennart Poettering's avatar
Lennart Poettering committed
110
                        free(fn);
111
                        r = EXIT_FAILURE;
112 113 114
                        continue;
                }

Lennart Poettering's avatar
Lennart Poettering committed
115 116
                free(fn);

117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
                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);
141
                                        r = EXIT_FAILURE;
142 143 144 145 146 147 148 149 150 151 152
                                        continue;
                                }

                                arguments = a;
                                n_allocated = m;
                        }

                        arguments[n_arguments++] = t;
                }

                if (ferror(f)) {
153
                        r = EXIT_FAILURE;
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
                        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");
169
                r = EXIT_FAILURE;
170 171 172 173 174 175
        }

        strv_free(arguments);

        return r;
}