usr.sbin/sysinstall/modules.c

   1 /*-
   2  * Copyright (c) 2000  "HOSOKAWA, Tatsumi" <hosokawa@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include "sysinstall.h"
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <sys/types.h>
  33 #include <sys/param.h>
  34 #include <sys/linker.h>
  35 #include <dirent.h>
  36 #include <fcntl.h>
  37 #include <fnmatch.h>
  38 #include <kenv.h>
  39
  40 /* Prototypes */
  41 static int              kldModuleFire(dialogMenuItem *self);
  42
  43 #define MODULESDIR "/modules"
  44 #define DISTMOUNT "/dist"
  45
  46 void
  47 moduleInitialize(void)
  48 {
  49     int fd, len;
  50     DIR *dirp;
  51     struct dirent *dp;
  52     char module[MAXPATHLEN], desc[MAXPATHLEN];
  53     char desc_str[BUFSIZ];
  54
  55     if (!RunningAsInit && !Fake) {
  56         /* It's not my job... */
  57         return;
  58     }
  59
  60     dirp = opendir(MODULESDIR);
  61     if (dirp) {
  62         while ((dp = readdir(dirp))) {
  63             if (dp->d_namlen < (sizeof(".ko") - 1)) continue;
  64             if (strcmp(dp->d_name + dp->d_namlen - (sizeof(".ko") - 1), ".ko") == 0) {
  65                 strcpy(module, MODULESDIR);
  66                 strcat(module, "/");
  67                 strcat(module, dp->d_name);
  68                 strcpy(desc, module);
  69                 len = strlen(desc);
  70                 strcpy(desc + (len - (sizeof(".ko") - 1)), ".dsc");
  71                 fd = open(module, O_RDONLY);
  72                 if (fd < 0) continue;
  73                 close(fd);
  74                 fd = open(desc, O_RDONLY);
  75                 if (fd < 0) {
  76                     desc_str[0] = 0;
  77                 }
  78                 else {
  79                     len = read(fd, desc_str, BUFSIZ);
  80                     close(fd);
  81                     if (len < BUFSIZ) desc_str[len] = 0;
  82                 }
  83                 if (desc_str[0])
  84                     msgDebug("Loading module %s (%s)\n", dp->d_name, desc_str);
  85                 else
  86                     msgDebug("Loading module %s\n", dp->d_name);
  87                 if (kldload(module) < 0 && errno != EEXIST) {
  88                     if (desc_str[0])
  89                         msgConfirm("Loading module %s failed\n%s", dp->d_name, desc_str);
  90                     else
  91                         msgConfirm("Loading module %s failed", dp->d_name);
  92                 }
  93             }
  94             if (strcmp(dp->d_name + dp->d_namlen - (sizeof(".ko.gz") - 1), ".ko.gz") == 0) {
  95                 snprintf(module, sizeof(module), "/tmp/%s", dp->d_name);
  96                 module[strlen(module) - sizeof(".gz")] = '\0';
  97                 snprintf(desc, sizeof(desc), "zcat < %s/%s > %s", MODULESDIR,
  98                   dp->d_name, module);
  99                 system(desc);
 100                 if (kldload(module) < 0 && errno != EEXIST) {
 101                     if (desc_str[0])
 102                         msgConfirm("Loading module %s failed\n%s", dp->d_name, desc_str);
 103                     else
 104                         msgConfirm("Loading module %s failed", dp->d_name);
 105                 }
 106                 unlink(module);
 107             }
 108         }
 109         closedir(dirp);
 110     }
 111 }
 112
 113 void
 114 driverFloppyCheck(void)
 115 {
 116     /* Prompt for the driver floppy if requested. */
 117     if (kenv(KENV_GET, "driver_floppy", NULL, 0) >= 0 &&
 118         !msgYesNo("Would you like to load kernel modules from the driver floppy?"))
 119         (void)kldBrowser(NULL);
 120 }
 121
 122 int
 123 kldBrowser(dialogMenuItem *self)
 124 {
 125     DMenu       *menu = NULL;
 126     int         i, what = DITEM_SUCCESS, msize, count;
 127     DIR         *dir;
 128     struct dirent *de;
 129     char        *err;
 130
 131     err = NULL;
 132     count = 0;
 133
 134     if (DITEM_STATUS(mediaSetFloppy(NULL)) == DITEM_FAILURE) {
 135         err = "Unable to set media device to floppy.";
 136         goto errout;
 137     }
 138
 139     if (!DEVICE_INIT(mediaDevice)) {
 140         err = "Unable to mount floppy filesystem.";
 141         goto errout;
 142     }
 143
 144     msize = sizeof(DMenu) + (sizeof(dialogMenuItem) * 2);
 145     if ((menu = malloc(msize)) == NULL) {
 146         err = "Failed to allocate memory for menu";
 147         goto errout;
 148     }
 149
 150     bcopy(&MenuKLD, menu, sizeof(DMenu));
 151
 152     bzero(&menu->items[count], sizeof(menu->items[0]));
 153     menu->items[count].prompt = strdup("X Exit");
 154     menu->items[count].title = strdup("Exit this menu (returning to previous)");
 155     menu->items[count].fire = dmenuExit;
 156     count++;
 157
 158     if ((dir = opendir(DISTMOUNT)) == NULL) {
 159         err = "Couldn't open directory";
 160         goto errout;
 161     }
 162
 163     while ((de = readdir(dir)) != NULL) {
 164         if (fnmatch("*.ko", de->d_name, FNM_CASEFOLD))
 165             continue;
 166
 167         msize += sizeof(dialogMenuItem);
 168         if ((menu = realloc(menu, msize)) == NULL) {
 169             err = "Failed to allocate memory for menu item";
 170             goto errout;
 171         }
 172
 173         bzero(&menu->items[count], sizeof(menu->items[0]));
 174         menu->items[count].fire = kldModuleFire;
 175
 176         menu->items[count].prompt = strdup(de->d_name);
 177         menu->items[count].title = menu->items[count].prompt;
 178
 179         count++;
 180     }
 181
 182     closedir(dir);
 183
 184     menu->items[count].prompt = NULL;
 185     menu->items[count].title = NULL;
 186
 187     dmenuOpenSimple(menu, FALSE);
 188
 189     deviceRescan();
 190
 191   errout:
 192     mediaClose();
 193     for (i = 0; i < count; i++)
 194         free(menu->items[i].prompt);
 195
 196     free(menu);
 197
 198     if (err != NULL) {
 199         what |= DITEM_FAILURE;
 200         if (!variable_get(VAR_NO_ERROR))
 201             msgConfirm("%s", err);
 202     }
 203
 204     return (what);
 205 }
 206
 207 static int
 208 kldModuleFire(dialogMenuItem *self) {
 209     char        fname[256];
 210
 211     bzero(fname, sizeof(fname));
 212     snprintf(fname, sizeof(fname), "%s/%s", DISTMOUNT, self->prompt);
 213
 214     if (kldload(fname) < 0 && errno != EEXIST) {
 215         if (!variable_get(VAR_NO_ERROR))
 216             msgConfirm("Loading module %s failed\n", fname);
 217     } else {
 218         if (!variable_get(VAR_NO_ERROR))
 219             msgConfirm("Loaded module %s OK", fname);
 220     }
 221
 222     return(0);
 223  }