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         msgConfirm("Unable to set media device to floppy.");
 136         what |= DITEM_FAILURE;
 137         mediaClose();
 138         return what;
 139     }
 140
 141     if (!DEVICE_INIT(mediaDevice)) {
 142         msgConfirm("Unable to mount floppy filesystem.");
 143         what |= DITEM_FAILURE;
 144         mediaClose();
 145         return what;
 146     }
 147
 148     msize = sizeof(DMenu) + (sizeof(dialogMenuItem) * 2);
 149     count = 0;
 150     if ((menu = malloc(msize)) == NULL) {
 151         err = "Failed to allocate memory for menu";
 152         goto errout;
 153     }
 154
 155     bcopy(&MenuKLD, menu, sizeof(DMenu));
 156
 157     bzero(&menu->items[count], sizeof(menu->items[0]));
 158     menu->items[count].prompt = strdup("X Exit");
 159     menu->items[count].title = strdup("Exit this menu (returning to previous)");
 160     menu->items[count].fire = dmenuExit;
 161     count++;
 162
 163     if ((dir = opendir(DISTMOUNT)) == NULL) {
 164         err = "Couldn't open directory";
 165         goto errout;
 166     }
 167
 168     while ((de = readdir(dir)) != NULL) {
 169         if (fnmatch("*.ko", de->d_name, FNM_CASEFOLD))
 170             continue;
 171
 172         msize += sizeof(dialogMenuItem);
 173         if ((menu = realloc(menu, msize)) == NULL) {
 174             err = "Failed to allocate memory for menu item";
 175             goto errout;
 176         }
 177
 178         bzero(&menu->items[count], sizeof(menu->items[0]));
 179         menu->items[count].fire = kldModuleFire;
 180
 181         menu->items[count].prompt = strdup(de->d_name);
 182         menu->items[count].title = menu->items[count].prompt;
 183
 184         count++;
 185     }
 186
 187     closedir(dir);
 188
 189     menu->items[count].prompt = NULL;
 190     menu->items[count].title = NULL;
 191
 192     dmenuOpenSimple(menu, FALSE);
 193
 194     mediaClose();
 195
 196     deviceRescan();
 197
 198   errout:
 199     for (i = 0; i < count; i++)
 200         free(menu->items[i].prompt);
 201
 202     free(menu);
 203
 204     if (err != NULL) {
 205         what |= DITEM_FAILURE;
 206         if (!variable_get(VAR_NO_ERROR))
 207             msgConfirm(err);
 208     }
 209
 210     return (what);
 211 }
 212
 213 static int
 214 kldModuleFire(dialogMenuItem *self) {
 215     char        fname[256];
 216
 217     bzero(fname, sizeof(fname));
 218     snprintf(fname, sizeof(fname), "%s/%s", DISTMOUNT, self->prompt);
 219
 220     if (kldload(fname) < 0 && errno != EEXIST) {
 221         if (!variable_get(VAR_NO_ERROR))
 222             msgConfirm("Loading module %s failed\n", fname);
 223     } else {
 224         if (!variable_get(VAR_NO_ERROR))
 225             msgConfirm("Loaded module %s OK", fname);
 226     }
 227
 228     return(0);
 229  }