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 <fcntl.h>
  36 #include <dirent.h>
  37 #include <fcntl.h>
  38 #include <fnmatch.h>
  39 #include <kenv.h>
  40
  41 /* Prototypes */
  42 static int              kldModuleFire(dialogMenuItem *self);
  43
  44 #define MODULESDIR "/modules"
  45 #define DISTMOUNT "/dist"
  46
  47 void
  48 moduleInitialize(void)
  49 {
  50     int fd, len;
  51     DIR *dirp;
  52     struct dirent *dp;
  53     char module[MAXPATHLEN], desc[MAXPATHLEN];
  54     char desc_str[BUFSIZ];
  55
  56     if (!RunningAsInit && !Fake) {
  57         /* It's not my job... */
  58         return;
  59     }
  60
  61     dirp = opendir(MODULESDIR);
  62     if (dirp) {
  63         while ((dp = readdir(dirp))) {
  64             if (dp->d_namlen < (sizeof(".ko") - 1)) continue;
  65             if (strcmp(dp->d_name + dp->d_namlen - (sizeof(".ko") - 1), ".ko") == 0) {
  66                 strcpy(module, MODULESDIR);
  67                 strcat(module, "/");
  68                 strcat(module, dp->d_name);
  69                 strcpy(desc, module);
  70                 len = strlen(desc);
  71                 strcpy(desc + (len - (sizeof(".ko") - 1)), ".dsc");
  72                 fd = open(module, O_RDONLY);
  73                 if (fd < 0) continue;
  74                 close(fd);
  75                 fd = open(desc, O_RDONLY);
  76                 if (fd < 0) {
  77                     desc_str[0] = 0;
  78                 }
  79                 else {
  80                     len = read(fd, desc_str, BUFSIZ);
  81                     close(fd);
  82                     if (len < BUFSIZ) desc_str[len] = 0;
  83                 }
  84                 if (desc_str[0])
  85                     msgDebug("Loading module %s (%s)\n", dp->d_name, desc_str);
  86                 else
  87                     msgDebug("Loading module %s\n", dp->d_name);
  88                 if (kldload(module) < 0 && errno != EEXIST) {
  89                     if (desc_str[0])
  90                         msgConfirm("Loading module %s failed\n%s", dp->d_name, desc_str);
  91                     else
  92                         msgConfirm("Loading module %s failed", dp->d_name);
  93                 }
  94             }
  95             if (strcmp(dp->d_name + dp->d_namlen - (sizeof(".ko.gz") - 1), ".ko.gz") == 0) {
  96                 snprintf(module, sizeof(module), "/tmp/%s", dp->d_name);
  97                 module[strlen(module) - sizeof(".gz")] = '\0';
  98                 snprintf(desc, sizeof(desc), "zcat < %s/%s > %s", MODULESDIR,
  99                   dp->d_name, module);
 100                 system(desc);
 101                 if (kldload(module) < 0 && errno != EEXIST) {
 102                     if (desc_str[0])
 103                         msgConfirm("Loading module %s failed\n%s", dp->d_name, desc_str);
 104                     else
 105                         msgConfirm("Loading module %s failed", dp->d_name);
 106                 }
 107                 unlink(module);
 108             }
 109         }
 110         closedir(dirp);
 111     }
 112 }
 113
 114 void
 115 driverFloppyCheck(void)
 116 {
 117     /* Prompt for the driver floppy if requested. */
 118     if (kenv(KENV_GET, "driver_floppy", NULL, 0) >= 0 &&
 119         !msgYesNo("Would you like to load kernel modules from the driver floppy?"))
 120         (void)kldBrowser(NULL);
 121 }
 122
 123 int
 124 kldBrowser(dialogMenuItem *self)
 125 {
 126     DMenu       *menu;
 127     int         i, what = DITEM_SUCCESS, msize, count;
 128     DIR         *dir;
 129     struct dirent *de;
 130     char        *err;
 131
 132     err = NULL;
 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     count = 0;
 146     if ((menu = malloc(msize)) == NULL) {
 147         err = "Failed to allocate memory for menu";
 148         goto errout;
 149     }
 150
 151     bcopy(&MenuKLD, menu, sizeof(DMenu));
 152
 153     bzero(&menu->items[count], sizeof(menu->items[0]));
 154     menu->items[count].prompt = strdup("X Exit");
 155     menu->items[count].title = strdup("Exit this menu (returning to previous)");
 156     menu->items[count].fire = dmenuExit;
 157     count++;
 158
 159     if ((dir = opendir(DISTMOUNT)) == NULL) {
 160         err = "Couldn't open directory";
 161         goto errout;
 162     }
 163
 164     while ((de = readdir(dir)) != NULL) {
 165         if (fnmatch("*.ko", de->d_name, FNM_CASEFOLD))
 166             continue;
 167
 168         msize += sizeof(dialogMenuItem);
 169         if ((menu = realloc(menu, msize)) == NULL) {
 170             err = "Failed to allocate memory for menu item";
 171             goto errout;
 172         }
 173
 174         bzero(&menu->items[count], sizeof(menu->items[0]));
 175         menu->items[count].fire = kldModuleFire;
 176
 177         menu->items[count].prompt = strdup(de->d_name);
 178         menu->items[count].title = menu->items[count].prompt;
 179
 180         count++;
 181     }
 182
 183     closedir(dir);
 184
 185     menu->items[count].prompt = NULL;
 186     menu->items[count].title = NULL;
 187
 188     dmenuOpenSimple(menu, FALSE);
 189
 190     deviceRescan();
 191
 192   errout:
 193     mediaClose();
 194     for (i = 0; i < count; i++)
 195         free(menu->items[i].prompt);
 196
 197     free(menu);
 198
 199     if (err != NULL) {
 200         what |= DITEM_FAILURE;
 201         if (!variable_get(VAR_NO_ERROR))
 202             msgConfirm(err);
 203     }
 204
 205     return (what);
 206 }
 207
 208 static int
 209 kldModuleFire(dialogMenuItem *self) {
 210     char        fname[256];
 211
 212     bzero(fname, sizeof(fname));
 213     snprintf(fname, sizeof(fname), "%s/%s", DISTMOUNT, self->prompt);
 214
 215     if (kldload(fname) < 0 && errno != EEXIST) {
 216         if (!variable_get(VAR_NO_ERROR))
 217             msgConfirm("Loading module %s failed\n", fname);
 218     } else {
 219         if (!variable_get(VAR_NO_ERROR))
 220             msgConfirm("Loaded module %s OK", fname);
 221     }
 222
 223     return(0);
 224  }