src/device.c

   1 /* device.c  -  Device access */
   2 /*
   3 Copyright 1992-1997 Werner Almesberger.
   4 Copyright 1999-2006 John Coffman.
   5 All rights reserved.
   6
   7 Licensed under the terms contained in the file 'COPYING' in the
   8 source directory.
   9
  10 */
  11
  12 #define _GNU_SOURCE
  13 #include <unistd.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #include <errno.h>
  19 #include <dirent.h>
  20 #include <limits.h>
  21 #include <time.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25
  26 #include "config.h"
  27 #include "lilo.h"
  28 #include "common.h"
  29 #include "temp.h"
  30 #include "device.h"
  31 #include "geometry.h"
  32 #include "partition.h"
  33 #include "cfg.h"
  34 #include "probe.h"
  35 #include "md-int.h"
  36
  37
  38 typedef struct _cache_entry {
  39     const char *name;
  40     int number;
  41     struct _cache_entry *next;
  42 } CACHE_ENTRY;
  43
  44 typedef struct _st_buf {
  45     struct _st_buf *next;
  46     struct stat st;
  47 } ST_BUF;
  48
  49
  50 static CACHE_ENTRY *cache = NULL;
  51
  52
  53 #if 1
  54 int yesno(char *prompt, int expect)
  55 {
  56     char *line, *pr2;
  57     int i;
  58     size_t n;
  59     int ret;
  60     if (expect) pr2 = "[Y/n]";
  61     else pr2 = "[N/y]";
  62
  63     fflush(stdout);
  64     do {
  65         fprintf(stderr, "%s%s", prompt, pr2);
  66         fflush(stderr);
  67         n = ret = 0;
  68         line = NULL;
  69         i = getline(&line, &n, stdin);
  70         if (i<0) exit(1);
  71         if (i==1) ret=expect|2;
  72         if (i>1) {
  73                 if (*line=='y'||*line=='Y') ret=1;
  74                 if (*line=='n'||*line=='N') ret=2;
  75         }
  76         if (ret) break;
  77         if (line) free(line);
  78     } while(1);
  79
  80     return ret&1;
  81 }
  82 #endif
  83
  84 static int scan_dir(ST_BUF *next,DEVICE *dev,char *parent,int number)
  85 {
  86     DIR *dp;
  87     struct dirent *dir;
  88     ST_BUF st,*walk;
  89     char *start;
  90
  91     if (verbose >= 5) printf("scan_dir: %s\n", parent);
  92     st.next = next;
  93     if ((dp = opendir(parent)) == NULL)
  94     die("opendir %s: %s",parent,strerror(errno));
  95     *(start = strchr(parent,0)) = '/';
  96     while ((dir = readdir(dp))) {
  97        strcpy(start+1,dir->d_name);
  98        if (stat(parent,&st.st) >= 0) {
  99           dev->st = st.st;
 100           if (S_ISBLK(dev->st.st_mode) && dev->st.st_rdev == number) {
 101               (void) closedir(dp);
 102               return 1;
 103               }
 104 #if 0
 105           if (S_ISDIR(dev->st.st_mode) && strcmp(dir->d_name,".") &&
 106             strcmp(dir->d_name,"..")) {
 107 #else
 108           /* stay out of all hidden directories (good for 2.6 kernel) */
 109           if (S_ISDIR(dev->st.st_mode) && (dir->d_name)[0] != '.' &&
 110             strcmp(dir->d_name, ".udev") && strcmp(dir->d_name, "fd")) {
 111 #endif
 112           for (walk = next; walk; walk = walk->next)
 113               if (stat_equal(&walk->st,&st.st)) break;
 114           if (!walk && scan_dir(&st,dev,parent,number)) {
 115               (void) closedir(dp);
 116               return 1;
 117               }
 118           }
 119        }
 120     }
 121     (void) closedir(dp);
 122     *start = 0;
 123     return 0;
 124 }
 125
 126
 127 static int lookup_dev(char *name,DEVICE *dev,int number)
 128 {
 129     CACHE_ENTRY **walk;
 130
 131     if (verbose>=5) printf("lookup_dev:  number=%04X\n", number);
 132     for (walk = &cache; *walk; walk = &(*walk)->next)
 133         if ((*walk)->number == number) {
 134 #if 0
 135             CACHE_ENTRY *here;
 136
 137             if (stat((*walk)->name,&dev->st) >= 0)
 138                 if (S_ISBLK(dev->st.st_mode) && dev->st.st_rdev == number) {
 139                     strcpy(name,(*walk)->name);
 140                     return 1;
 141                 }
 142             here = *walk; /* remove entry from cache */
 143             if (verbose >= 2)
 144                 printf("Invalidating cache entry for %s (0x%04X)\n",here->name,
 145                   here->number);
 146             *walk = here->next;
 147             free((char *) here->name);
 148             free(here);
 149             return 0;
 150 #else
 151             strcpy(name,(*walk)->name);
 152             return 1;
 153 #endif
 154         }
 155     return 0;
 156 }
 157
 158
 159 static int is_devfs(void)
 160 {
 161 static int yesno = 0;
 162     struct stat st;
 163
 164     if (!yesno) {
 165         if (stat(DEV_DIR "/.devfsd", &st) < 0)  yesno=1;
 166         else yesno=2;
 167     }
 168
 169    return yesno-1;
 170 }
 171
 172
 173
 174 static void cache_add(const char *name,int number)
 175 {
 176     CACHE_ENTRY *entry;
 177
 178     entry = cache;
 179     while (entry) {
 180         if (strcmp(entry->name, name) == 0) {
 181             if (entry->number != number) die("cache_add: LILO internal error");
 182             return;
 183         }
 184         entry = entry->next;
 185     }
 186     if (verbose >= 5) printf("Caching device %s (0x%04X)\n",name,number);
 187     entry = alloc_t(CACHE_ENTRY);
 188     entry->name = stralloc(name);
 189     entry->number = number;
 190     entry->next = cache;
 191     cache = entry;
 192 }
 193
 194
 195 int dev_open(DEVICE *dev,int number,int flags)
 196 {
 197     char name[PATH_MAX];
 198     ST_BUF st;
 199     int count;
 200
 201     if (lookup_dev(name,dev,number)) dev->delete = 0;
 202     else {
 203         if (stat(DEV_DIR,&st.st) < 0)
 204             die("stat " DEV_DIR ": %s",strerror(errno));
 205         st.next = NULL;
 206         dev->delete = !scan_dir(&st,dev,strcpy(name,DEV_DIR),number);
 207         if (dev->delete) {
 208             for (count = 0; count <= MAX_TMP_DEV; count++) {
 209 #ifdef LCF_USE_TMPDIR
 210                 if (!strncmp(TMP_DEV,"/tmp/",5) && getenv("TMPDIR")) {
 211                     strcpy(name,getenv("TMPDIR"));
 212                     sprintf(name+strlen(name),TMP_DEV+4,count);
 213                 }
 214                 else
 215 #endif
 216                     sprintf(name,TMP_DEV,count);
 217                 if (stat(name,&dev->st) < 0) break;
 218             }
 219             if (count > MAX_TMP_DEV)
 220                 die("Failed to create a temporary device");
 221             if (mknod(name,0600 | S_IFBLK,number) < 0)
 222                 die("mknod %s: %s",name,strerror(errno));
 223             if (stat(name,&dev->st) < 0)
 224                 die("stat %s: %s",name,strerror(errno));
 225             if (verbose > 1)
 226                 printf("Created temporary device %s (0x%04X)\n",name,number);
 227             temp_register(name);
 228         }
 229         else cache_add(name,number);
 230     }
 231 #if BETA_TEST
 232         if (verbose >= 4) printf("stat-ing %s\n", name);
 233         fflush(stdout);
 234         stat(name, &st.st);
 235 #endif
 236     if (flags == O_BYPASS) dev->fd = -1;
 237     else if ((dev->fd = open(name,flags)) < 0) {
 238             fprintf (errstd, "Cannot proceed. Maybe you need to add "
 239                         "this to your lilo.conf:\n"
 240                          "\tdisk=%s inaccessible\n"
 241                         "(real error shown below)\n", name);
 242             die("open %s: %s",name,strerror(errno));
 243     }
 244     dev->name = stralloc(name);
 245     return dev->fd;
 246 }
 247
 248
 249 void dev_close(DEVICE *dev)
 250 {
 251     if (dev->fd != -1)
 252         if (close(dev->fd) < 0) die("close %s: %s",dev->name,strerror(errno));
 253     if (dev->delete) {
 254         if (verbose > 1)
 255             printf("Removed temporary device %s (0x%04X)\n",dev->name,
 256               (unsigned int) dev->st.st_rdev);
 257         (void) remove(dev->name);
 258         temp_unregister(dev->name);
 259     }
 260     free(dev->name);
 261 }
 262
 263 #define MAX 15
 264
 265 void cache_scsi (char *name, int major)
 266 {
 267     char tem[PATH_MAX], format[PATH_MAX];
 268     int i, j, dev;
 269     int k = strlen(DEV_DISK_DIR) + 3;
 270
 271     for (i=15; i>=0; i--) {
 272         dev = MKDEV(major,(i<<4));
 273 #if 0
 274         if (is_devfs()) {
 275             sprintf(tem,"/dev/scsi/host%d/bus0/target0/lun0/", i);
 276             strcat(strcpy(format,tem),"disc");
 277             cache_add(format, dev);
 278             strcat(strcpy(format,tem),"part%d");
 279         }
 280         else
 281 #endif
 282         {
 283             strcpy(format, name);
 284             format[k] += i;
 285             cache_add(format, dev);
 286             strcat(format, "%d");
 287         }
 288         for (j = MAX; j; j--) {
 289             sprintf(tem, format, j);
 290             cache_add(tem, dev | j);
 291         }
 292     }
 293 }
 294
 295
 296 void cache_ide (char *name, int major)
 297 {
 298     char tem[PATH_MAX], tem2[PATH_MAX];
 299     char format[PATH_MAX];
 300     char *disc;
 301     int i, dev, minor, host, bus, target;
 302     int j = strlen(DEV_DISK_DIR) + 3;
 303
 304     i = name[j] - 'a';
 305     target = i&1;
 306     minor = target<<6;
 307     i >>= 1;
 308     bus = i&1;
 309     host = i&(-2);
 310     if (is_devfs()) {
 311         sprintf(tem2, DEV_DIR "/ide/host%d/bus%d/target%d/lun0/", host, bus, target);
 312         strcat(strcpy(format,tem2), "part%d");
 313         disc = strcat(tem2, "disc");
 314     }
 315     else {
 316         strcat(strcpy(format, name), "%d");
 317         disc = name;
 318     }
 319     dev = MKDEV(major,minor);
 320     for (i = MAX; i; i--) {
 321         sprintf(tem, format, i);
 322         cache_add(tem, dev | i);
 323     }
 324     cache_add(disc, dev);
 325 }
 326
 327 void preload_dev_cache(void)
 328 {
 329     char tmp[PATH_MAX];
 330     int i;
 331     int vsave;
 332
 333
 334     vsave = verbose;
 335 #if !BETA_TEST
 336     if (verbose>0) verbose--;
 337 #endif
 338
 339     if (is_devfs()) {
 340         cache_add(DEV_DIR "/floppy/0", 0x0200);
 341         cache_add(DEV_DIR "/floppy/1", 0x0201);
 342     }
 343     else {
 344         cache_add(DEV_DIR "/fd0", 0x0200);
 345         cache_add(DEV_DIR "/fd1", 0x0201);
 346     }
 347
 348 #if 1
 349     cache_ide(DEV_DISK_DIR "/hdt", MAJOR_IDE10);
 350     cache_ide(DEV_DISK_DIR "/hds", MAJOR_IDE10);
 351     cache_ide(DEV_DISK_DIR "/hdr", MAJOR_IDE9);
 352     cache_ide(DEV_DISK_DIR "/hdq", MAJOR_IDE9);
 353
 354     cache_ide(DEV_DISK_DIR "/hdp", MAJOR_IDE8);
 355     cache_ide(DEV_DISK_DIR "/hdo", MAJOR_IDE8);
 356     cache_ide(DEV_DISK_DIR "/hdn", MAJOR_IDE7);
 357     cache_ide(DEV_DISK_DIR "/hdm", MAJOR_IDE7);
 358
 359     cache_ide(DEV_DISK_DIR "/hdl", MAJOR_IDE6);
 360     cache_ide(DEV_DISK_DIR "/hdk", MAJOR_IDE6);
 361 #ifdef MAJOR_IDE5
 362     cache_ide(DEV_DISK_DIR "/hdj", MAJOR_IDE5);
 363     cache_ide(DEV_DISK_DIR "/hdi", MAJOR_IDE5);
 364 #endif
 365 #endif
 366
 367     for (i = MAX; i >= 0; i--) {
 368         sprintf(tmp, is_devfs() ? DEV_DISK_DIR "/md/%d" : DEV_DISK_DIR "/md%d", i);
 369         cache_add(tmp, MKDEV(MAJOR_MD,i));
 370     }
 371
 372     if (!is_devfs()) cache_scsi(DEV_DISK_DIR "/sda", MAJOR_SD);
 373
 374     cache_ide(DEV_DISK_DIR "/hdh", MAJOR_IDE4);
 375     cache_ide(DEV_DISK_DIR "/hdg", MAJOR_IDE4);
 376     cache_ide(DEV_DISK_DIR "/hdf", MAJOR_IDE3);
 377     cache_ide(DEV_DISK_DIR "/hde", MAJOR_IDE3);
 378
 379     for (i = 0; i <= 7; i++) {
 380         sprintf(tmp, is_devfs() ? DEV_DIR "/loop/%d" : DEV_DIR "/loop%d", i);
 381         cache_add(tmp,0x700+i);
 382     }
 383
 384     cache_ide(DEV_DISK_DIR "/hdd", MAJOR_IDE2);
 385     cache_ide(DEV_DISK_DIR "/hdc", MAJOR_IDE2);
 386     cache_ide(DEV_DISK_DIR "/hdb", MAJOR_HD);
 387     cache_ide(DEV_DISK_DIR "/hda", MAJOR_HD);
 388
 389     verbose = vsave;
 390 }
 391
 392 #undef MAX
 393
 394 #define NDEVICE 256
 395 static unsigned int idevices[NDEVICE];
 396 static int maxdev = 0;
 397
 398 /* return 0 if device has not been backed up,           */
 399 /*        1 if it has been backed up                    */
 400
 401 static int dev_listed(unsigned short dev)
 402 {
 403     int i;
 404
 405 /* scan the device list */
 406     for (i=0; i<maxdev; i++) {
 407         if (dev==idevices[i]) return 1;         /* already backed up */
 408     }
 409
 410     if (maxdev < NDEVICE-1) idevices[maxdev++] = dev;
 411
 412     return 0;   /* new to the list, not listed if too many devices */
 413 }
 414
 415
 416 /* make a backup, returning the timestamp of the backup file */
 417 /* 0 if no timestamp returned, and no backup file created */
 418
 419 int make_backup(char *backup_file, int force_backup, BOOT_SECTOR *bsect,
 420         unsigned int device, char *id)
 421 {
 422     struct stat st;
 423     char temp_name[PATH_MAX];
 424     int bck_file;
 425     int timestamp=0;
 426     char *filename = "boot";
 427
 428     char *cp = NULL;
 429     int force = 0;
 430
 431
 432     if ((cp=cfg_get_strg(cf_options,"force-backup"))) force=1;
 433     else cp=cfg_get_strg(cf_options,"backup");
 434     if (!backup_file) {
 435         backup_file = cp;
 436         force_backup = force;
 437     }
 438
 439     if (backup_file && stat(backup_file, &st) >= 0) {
 440 /* file or directory exists */
 441         if (S_ISDIR(st.st_mode)) {
 442             if (strcmp(backup_file,"/")==0) backup_file = "";
 443             sprintf(temp_name, "%s/%s.%04X", backup_file, filename, device);
 444             backup_file = temp_name;
 445         }
 446     /* test for /dev/null */
 447         else if (S_ISCHR(st.st_mode) && st.st_rdev==0x0103) return 0;
 448         else if (!S_ISREG(st.st_mode))
 449             die("make_backup: %s not a directory or regular file", backup_file);
 450     }
 451
 452 /* could not stat it, or it was a directory, or it was a regular file */
 453
 454     if (backup_file) {
 455         char *name, *dir, suffix[16];
 456
 457         backup_file = strcpy(temp_name, backup_file);
 458         sprintf(suffix, "%04X", device);
 459         dir = strrchr(backup_file, '/');
 460         if (!dir) dir = backup_file;
 461         name = strrchr(dir, '.');
 462         if (name) {  /* there is a '.' in the name */
 463             if (strcmp(name+1, suffix)==0) ; /* do nothing */
 464             else if (strlen(name+1)==4) {  /* && the suffix doesn't match */
 465                 strcpy(name+1,suffix);
 466             }
 467             else if (name[1]==0) strcat(name,suffix);   /* ended with '.' */
 468             else {
 469                 strcat(name+1,".");
 470                 strcat(backup_file,suffix);
 471             }
 472           /* we now have the filename with the correct suffix */
 473         }
 474         else {
 475     /* no '.' in the name, take it as a template */
 476             strcat(backup_file,".");
 477             strcat(backup_file,suffix);
 478         }
 479     }
 480     else
 481   /*  if (!backup_file) */ {
 482         sprintf(temp_name, BACKUP_DIR "/%s.%04X", filename, device);
 483         backup_file = temp_name;
 484     }
 485
 486     bck_file = open(backup_file, O_RDONLY);
 487     if (bck_file >= 0 && force_backup) {
 488         (void) close(bck_file);
 489         bck_file = -1;
 490     }
 491     if (bck_file >= 0) {
 492         if (verbose)
 493             printf("%s exists - no %s backup copy made.\n", backup_file, id);
 494     }
 495     else {
 496         if (dev_listed(device)) {
 497             if (verbose)
 498                 printf("Backup copy of %s has already been made in %s\n",
 499                         id, backup_file);
 500         }
 501         else if (!test) {
 502             if ((bck_file = creat(backup_file, 0644)) < 0)
 503                 die("creat %s: %s",backup_file, strerror(errno));
 504             if (write(bck_file, (char *)bsect, SECTOR_SIZE) != SECTOR_SIZE)
 505                 die("write %s: %s", backup_file, strerror(errno));
 506             if (verbose)
 507                 printf("Backup copy of %s in %s\n", id, backup_file);
 508             if (fstat(bck_file, &st) < 0)
 509                 die("fstat %s: %s",backup_file,strerror(errno));
 510             timestamp = st.st_mtime;
 511         }
 512         else {
 513             if (verbose)
 514                 printf("Backup copy of %s in %s (test mode)\n", id, backup_file);
 515         }
 516     }
 517     if (bck_file >= 0 && close(bck_file) < 0) die("close %s: %s",backup_file,strerror(errno));
 518
 519     return timestamp;
 520 }
 521
 522
 523
 524
 525 int serial_valid(unsigned int serial, int disk_bios)
 526 {
 527 #if 1
 528     return (serial != 0);
 529 #elif 1
 530     if (serial == -1 || serial == 0) return 0;
 531     return 1;
 532 #else
 533 /* if ID is replicated characters, it is invalid */
 534 /*      Examples of invalid Volume ID's are:
 535                 00000000
 536                 6C6C6C6C
 537                 FFFFFFFF
 538 BUT: any Volume ID (except 0 or -1) is valid on drive C:
 539  - - - - - - - - - - - - - - - - - - - - - - - - - - */
 540     unsigned int temp;
 541
 542     temp = serial & 0xFF;
 543     temp |= temp << 8;
 544     temp |= temp << 16;
 545
 546     return (serial != temp ||
 547                 (serial!=0 && serial!=0xFFFFFFFFUL && disk_bios==0x80));
 548 #endif
 549 }
 550
 551 int new_serial(int dev)
 552 {
 553 static int inited = 0;
 554
 555     if (!inited) {
 556         struct stat st;
 557         int fd, random;
 558 #define RANDOM DEV_DIR "/urandom"
 559
 560         inited = time(NULL);
 561         if ( stat(RANDOM, &st)==0 && S_ISCHR(st.st_mode)
 562             && (fd = open(RANDOM, O_RDONLY)) > 0
 563             && read(fd, &random, sizeof(random)) == sizeof(random) )  {
 564 #if BETA_TEST
 565 if(verbose>=5) printf("Using " RANDOM " for seeding random number generator\n");
 566 #endif
 567                 close(fd);
 568                 inited ^= random;
 569         }
 570
 571         srand(inited);
 572     }
 573     dev = dev % PRIME + SMALL_PRIME;
 574     while(dev--) inited = rand();
 575
 576     return inited;
 577 #undef RANDOM
 578 }
 579
 580
 581
 582
 583 static int inited = 0;
 584 unsigned int serial_no[MAX_BIOS_DEVICES];
 585 static int device_code[MAX_BIOS_DEVICES];
 586
 587 /*  register references to various bios devices
 588  *  compiles the list of volume IDs
 589  *    returns volume ID on success
 590  *      0 = no volume ID
 591  *      -1 = error
 592  */
 593 unsigned int register_bios(int bios, int device)
 594 {
 595     int i, fd, valid, disk_bios;
 596     DEVICE dev;
 597     BOOT_SECTOR buff;
 598     unsigned int serial = -1;
 599
 600 #if 0
 601     if (!inited) {
 602         for (i=0; i<MAX_BIOS_DEVICES; i++) {
 603             device_code[i] = 0;
 604             serial_no[i] = 0;
 605         }
 606         inited = 1;
 607         srand(time(NULL));
 608     }
 609 #else
 610     inited = 1;
 611 #endif
 612     if (!do_md_install && cfg_get_flag(cf_options, "static-bios-codes")) return 0;
 613
 614     if (verbose>=4) {
 615         printf("registering bios=0x%02X  device=0x%04X\n", bios, device);
 616     }
 617
 618     disk_bios = bios;
 619     if (bios>=0x80 && bios<0x80+MAX_BIOS_DEVICES &&
 620                                 (i=has_partitions(device))) {
 621         bios &= 0x7F;   /* mask to index */
 622         device &= i;    /* mask to master device */
 623         if (device_code[bios]==0 && serial_no[bios]==0) {  /* slot empty */
 624             fd = dev_open(&dev, device, O_RDWR);
 625             if (lseek(fd, 0L, SEEK_SET) < 0)
 626                 die("master boot record seek %04X: %s", device, strerror(errno));
 627             if (read(fd, (char*)&buff, SECTOR_SIZE)!=SECTOR_SIZE)
 628                 die("read master boot record %04X: %s", device, strerror(errno));
 629             serial = *(int*)&buff.sector[PART_TABLE_OFFSET-6];
 630             valid = serial_valid(serial, disk_bios);
 631             if ((!valid || (VERSION_MINOR>=50)) && !test)
 632                     make_backup(NULL, 0, &buff, device,
 633                                         "master disk volume ID record");
 634             if (!valid) {
 635                 i = device % PRIME + SMALL_PRIME;
 636                 while(i--) serial = rand();
 637                 for (; i<5 && !serial_valid(serial, disk_bios); i++) serial = rand();
 638                 if (!serial_valid(serial, disk_bios)) die("Volume ID generation error");
 639
 640                 *(int*)&buff.sector[PART_TABLE_OFFSET-6] = serial;
 641                 if (*(short*)&buff.sector[PART_TABLE_OFFSET - 2] == 0)
 642                     *(short*)&buff.sector[PART_TABLE_OFFSET - 2] = MAGIC_SERIAL;
 643                 if (verbose)
 644                     printf("Assigning new Volume ID to (%04X) '%s'  ID = %08X\n",
 645                                         device, dev.name, (int)serial);
 646                 if (!test) {
 647                     i = lseek(fd, 0L, SEEK_SET);
 648                     if (i<0) die("master boot record2 seek %04X: %s", device, strerror(errno));
 649                     if (write(fd, (char*)&buff, SECTOR_SIZE)!=SECTOR_SIZE)
 650                         die("write master boot record %04X: %s", device, strerror(errno));
 651                 }
 652             }
 653             dev_close(&dev);
 654             for (i=0; i<MAX_BIOS_DEVICES; i++) {
 655                 if (device_code[i]==device)
 656                     die("register_bios: device code duplicated: %04X", device);
 657                 if (serial_no[i]==serial)
 658                     die("register_bios: volume ID serial no. duplicated: %08lX", serial);
 659             }
 660             device_code[bios] = device;
 661             serial_no[bios] = serial;
 662         }
 663
 664
 665         if (device_code[bios]==device) serial = serial_no[bios];
 666         else {
 667             DEVICE dev, deva;
 668
 669             dev_open(&dev, device_code[bios], O_BYPASS);
 670             dev_open(&deva, device, O_BYPASS);
 671
 672             die("Bios device code 0x%02X is being used by two disks\n\t%s (0x%04X)  and  %s (0x%04X)",
 673                 bios|0x80, dev.name, device_code[bios], deva.name, device);
 674         }
 675         if (verbose>=3) {
 676             printf("Using Volume ID %08X on bios %02X\n", (int)serial, bios+0x80);
 677         }
 678     }
 679     else if (bios>=0 && bios <=3) serial = 0;
 680     else serial = -1;
 681
 682     return serial;
 683 }
 684
 685
 686 void dump_serial_nos(void)
 687 {
 688     int i,j;
 689
 690     printf(" BIOS   VolumeID   Device\n");
 691     if (!inited) return;
 692     for (j=nelem(serial_no); serial_no[--j]==0; )   ;
 693     for (i=0; i<=j; i++)
 694         printf("  %02X    %08X    %04X\n",
 695                 i+0x80,
 696                 (int)serial_no[i],
 697                 (int)device_code[i]
 698         );
 699 }
 700
 701
 702 enum {ID_GET=0, ID_SET};
 703
 704 static int volid_get_set(int device, int vol_in, int option)
 705 {
 706     BOOT_SECTOR buf;
 707     DEVICE dev;
 708     int fd;
 709     int temp;
 710     unsigned short word;
 711
 712     if (!has_partitions(device) && (device & P_MASK(device)) )
 713         die("VolumeID set/get bad device %04X\n", device);
 714
 715     fd = dev_open(&dev, device, option ? O_RDWR : O_RDONLY);
 716     if (read(fd, &buf, sizeof(buf)) != sizeof(buf)) {
 717         fprintf (errstd, "Cannot proceed. Maybe you need to add "
 718                         "this to your lilo.conf:\n"
 719                          "\tdisk=%s inaccessible\n"
 720                         "(real error shown below)\n", dev.name);
 721         die("VolumeID read error: sector 0 of %s not readable", dev.name);
 722     }
 723     if (option==ID_SET) {
 724         make_backup(NULL, 0, &buf, device,
 725                                         "master disk volume ID record");
 726         word = temp = buf.boot.volume_id & 0xFF;        /* one char */
 727         word |= word << 8;
 728         temp = word;
 729         temp |= temp << 16;
 730         if (buf.boot.mbz==word
 731                 && buf.boot.volume_id==temp
 732                 && buf.boot.marker==word) {
 733             buf.boot.mbz = buf.boot.marker = 0;
 734         }
 735         buf.boot.volume_id = vol_in;
 736         if (buf.boot.marker == 0) buf.boot.marker = MAGIC_SERIAL;
 737         if (!test) {
 738             if (lseek(fd, 0L, SEEK_SET) != 0L  ||
 739                     write(fd, &buf, PART_TABLE_OFFSET) != PART_TABLE_OFFSET )
 740                 die("volid write error");
 741         }
 742     }
 743     dev_close(&dev);
 744     sync(); /* critical that this be done here */
 745
 746     return buf.boot.volume_id;
 747 }
 748
 749
 750
 751
 752 /* count the number of slashes in a pathname */
 753 static int slashes(char *cp)
 754 {
 755     int n = 0;
 756
 757     while ( (cp=strchr(++cp,'/')) )  n++;
 758
 759     return n;
 760 }
 761
 762
 763 static int ndevs=0;
 764 enum {INVALID=1, DUPLICATE=2, REGENERATE=3, NTCAUTION=4};
 765
 766 struct VolumeMgmt {
 767     char *name;         /* the name of the disk; e.g.  "/dev/hda" */
 768     unsigned int device;        /* the device number (major, minor) */
 769     int sort;           /* the device number used for sorting */
 770     int flag;           /* various flag bits */
 771     char nt[PART_MAX];  /* flag partitions which might be NT */
 772     DT_ENTRY *dt;       /* pointer to any disktab entry */
 773     struct {
 774         int kernel;     /* volume ID as read using kernel I/O */
 775         int probe;      /* volume ID as probed */
 776     } vol_id;
 777     struct {
 778         int user;       /* user used a disk= bios= section */
 779         int probe;      /* passed in from the BIOS data check */
 780         int actual;     /* this is what we finally decide upon */
 781     } bios;             /* BIOS device codes */
 782 };
 783
 784
 785 #ifdef LCF_MDPRAID
 786 /* return boolean if VM is a component drive of MDP-RAID */
 787
 788 static int is_mdp(struct VolumeMgmt *vm, struct VolumeMgmt *mdp)
 789 {
 790     int mdp_fd;
 791     DEVICE dev;
 792     struct md_version md_version_info;
 793     md_array_info_t raid;
 794     int ret=0;
 795
 796     if (verbose>=2) printf("is_mdp:   %04X : %04X\n",
 797           vm->device, mdp->device);
 798
 799     if ((mdp_fd=dev_open(&dev, mdp->device, O_NOACCESS) ) < 0)
 800         die("Unable to open %s", mdp->name);
 801
 802     if (ioctl(mdp_fd, RAID_VERSION, &md_version_info) < 0) ret = -1;
 803     else if (md_version_info.major > 0  ||
 804                           md_version_info.minor < 90) {
 805
 806         ret = -2;
 807         warn("RAID versions other than 0.90 are not supported");
 808     }
 809     else if (ioctl(mdp_fd, GET_ARRAY_INFO, &raid) < 0) ret = -1;
 810     else if (raid.level == 1) {
 811         md_disk_info_t disk;
 812         int i;
 813
 814         for (i=0; ret==0 && i<raid.active_disks; i++) {
 815             disk.number = i;
 816             if (ioctl(mdp_fd, GET_DISK_INFO, &disk) < 0) ret = -1;
 817             if (vm->device == MKDEV(disk.major, disk.minor)) ret = 1;
 818         }
 819     }
 820     /* else ret = 0;  already */
 821     dev_close(&dev);
 822
 823     if (verbose>=2) printf("is_mdp: returns %d\n", ret);
 824
 825     return ret;
 826 }
 827 #endif
 828
 829 /*
 830    Returns 0 if not an NT, 2000, or XP boot disk (query user)
 831    returns 1 if it is an NT ... boot disk; abort if fatal set
 832 */
 833 static int winnt_check(struct VolumeMgmt *vm, int fatal)
 834 {
 835     int dev, ret;
 836
 837     if ( !(vm->flag & NTCAUTION) ) return 0;
 838
 839     dev = vm->device;
 840
 841     fflush(stdout);
 842     fflush(stderr);
 843
 844     fprintf(stderr, "\n\nReference:  disk \"%s\"  (%d,%d)  %04X\n\n"
 845 "LILO wants to assign a new Volume ID to this disk drive.  However, changing\n"
 846 "the Volume ID of a Windows NT, 2000, or XP boot disk is a fatal Windows error.\n"
 847 "This caution does not apply to Windows 95 or 98, or to NT data disks.\n"
 848                                 , vm->name, MAJOR(dev), MINOR(dev), dev);
 849
 850
 851     ret = yesno("\nIs the above disk an NT boot disk? ", 1);
 852
 853     if (ret && fatal) {
 854         fprintf(stderr, "Aborting ...\n");
 855         exit(0);
 856     }
 857
 858     return ret;
 859 }
 860
 861
 862
 863 #ifdef LCF_MDPRAID
 864 #define SORT(d) (MAJOR(d)==MAJOR_SD?MKDEV(MAJOR_SD_SORT,MINOR(d)):\
 865                  MAJOR(d)==MAJOR_MDP?MKDEV(MAJOR_MDP_SORT,MINOR(d)):\
 866                  MAJOR(d)==MAJOR_EMD?MKDEV(MAJOR_EMD_SORT,MINOR(d)):\
 867                  MAJOR(d)==MAJOR_HPT370?MKDEV(MAJOR_HPT370_SORT,MINOR(d)):\
 868                  (d))
 869 #else
 870 #define SORT(d) (MAJOR(d)==MAJOR_SD?MKDEV(MAJOR_SD_SORT,MINOR(d)):\
 871                  MAJOR(d)==MAJOR_EMD?MKDEV(MAJOR_EMD_SORT,MINOR(d)):\
 872                  MAJOR(d)==MAJOR_HPT370?MKDEV(MAJOR_HPT370_SORT,MINOR(d)):\
 873                  (d))
 874 #endif
 875
 876 int pf_hard_disk_scan(void)
 877 {
 878     struct VolumeMgmt vm [MAX_DEVICES];
 879 static int warned = 0, called = 0;
 880     char *line, *next, *name;
 881     int major, minor, i, ipart;
 882     int dev, mask, bios;
 883     unsigned int device;
 884     size_t n;
 885     DEVICE Dev;
 886     DT_ENTRY *walk;
 887     struct stat st;
 888     int duplicate = 0, invalid = 0, ret = 0, ntcaution = 0;
 889     int raidcaution = 0;
 890     long codes = 0L;
 891
 892 /* called from  raid_setup  &  from  geo_open */
 893 /* allow only 1 call */
 894     if (called || cfg_get_flag(cf_options,"static-bios-codes")) return ret;
 895     called = 1;
 896     memset(vm,0,sizeof(vm));    /* for consistency */
 897
 898 #if 1
 899     if (!pp_fd  &&  (pp_fd = fopen(PARTITIONS, "r"))==NULL) {
 900 #else
 901     if ((pp_fd = fopen(PARTITIONS, "r"))==NULL || fetch()) {
 902 #endif
 903         warn("'" PARTITIONS "' does not exist, disk scan bypassed");
 904         return 1;
 905     }
 906
 907     n = 0;
 908     line = NULL;
 909     while (!feof(pp_fd)) {
 910         if (line) {
 911             free(line);
 912             line = NULL;
 913             n = 0;
 914         }
 915         if (getline(&line, &n, pp_fd) <= 0) break;
 916
 917         major = strtoul(line, &next, 10);
 918         if (major==0 || line==next) continue;
 919
 920         if (is_dm_major(major)) {
 921 #ifndef LCF_DEVMAPPER
 922             warn("device-mapper (%d) referenced in " PARTITIONS ",\n"
 923                  "   but LILO is configured without DEVMAPPER option.  Skipping device.", major);
 924             continue;
 925 #endif
 926         }
 927         else if ((major>=60 && major<=63) || (major>=120 && major<=127) ) {
 928             warn(PARTITIONS " references Experimental major device %d.", major);
 929         }
 930         else if (major==255) {
 931             warn(PARTITIONS " references Reserved device 255.");
 932             continue;
 933         }
 934         else if (major>=240 && major<255) {
 935             warn(PARTITIONS " references Experimental major device %d.", major);
 936         }
 937
 938         minor = strtoul(next, &name, 10);
 939         if (next==name) continue;
 940         /* skip */ strtoull(name,&next,10);
 941
 942         while (isspace(*next)) next++;
 943         name = next;
 944         while (*name && !isspace(*name)) name++;
 945         *name = 0;
 946         if (strncmp(DEV_DISK_DIR "/", next, strlen(DEV_DISK_DIR)+1) != 0) name = next-(strlen(DEV_DISK_DIR)+1);
 947         else name = next;
 948         if (*name=='/') name++;
 949         strncpy(name, DEV_DISK_DIR "/", strlen(DEV_DISK_DIR)+1);
 950         if (verbose>=5) {
 951             printf("pf_hard_disk_scan: (%d,%d) %s\n", major, minor, name);
 952         }
 953
 954         device = MKDEV(major, minor);
 955
 956         Dev.delete = 0;
 957         if (stat(name, &st) < 0) {
 958             dev_open(&Dev, device, O_BYPASS);
 959             if (!warned) {
 960                 warn("'" PARTITIONS "' does not match '" DEV_DISK_DIR "' directory structure.\n"
 961                                 "    Name change: '%s' -> '%s'%s"
 962                                 ,       name, Dev.name,
 963                                 slashes(name) > 3 && slashes(Dev.name) < 3 ? "\n"
 964                                 "    The kernel was compiled with DEVFS_FS, but 'devfs=mount' was omitted\n"
 965                                 "        as a kernel command-line boot parameter; hence, the '" DEV_DISK_DIR "' directory\n"
 966                                 "        structure does not reflect DEVFS_FS device names."
 967                         :       slashes(name) < 3 && slashes(Dev.name) > 3 ? "\n"
 968                                 "    The kernel was compiled without DEVFS, but the '" DEV_DISK_DIR "' directory structure\n"
 969                                 "        implements the DEVFS filesystem."
 970                         :
 971                                 ""
 972                                 );
 973                 warned++;
 974             }
 975             else {
 976                 warn("Name change: '%s' -> '%s'", name, Dev.name);
 977             }
 978             name = Dev.name;
 979             if (Dev.delete) {
 980                 warn("'" DEV_DISK_DIR "' directory structure is incomplete; device (%d, %d) is missing.",
 981                                 major, minor);
 982                 cache_add(name, device);
 983             }
 984         }
 985         else cache_add(name, device);
 986
 987         mask = has_partitions(device);
 988         dev = device & mask;    /* dev is the master device */
 989         ipart = device & P_MASK(device); /* ipart is the partition number */
 990
 991 #if 1
 992         for (walk=disktab; walk; walk=walk->next) {
 993             if (walk->device == dev) {
 994                 if (walk->heads == 0 /* inaccessible */) {
 995                     if (ipart==0 && !identify)
 996                         warn("bypassing VolumeID scan of drive flagged INACCESSIBLE:  %s", name);
 997                     ipart = -1; /* causes skip below */
 998                 }
 999                 break;
1000             }
1001         }
1002 #endif
1003         if (mask && ipart>0) {
1004             int found;
1005             int serial;
1006
1007             for (found=i=0; i<ndevs && !found; i++) {
1008                 if (dev==vm[i].device) found = i+1;
1009             }
1010             if (!found) {
1011                 DEVICE Dev2;
1012                 serial = volid_get_set(dev, 0, ID_GET);
1013
1014 #if 0
1015 /* take care of uninitialized Volume IDs with no fanfare */
1016                 if (serial==0) {
1017                     serial = volid_get_set(dev, new_serial(dev), ID_SET);
1018                 }
1019 #endif
1020 #if BETA_TEST
1021                 if (verbose>=3) printf("**ndevs=%d\n", ndevs);
1022 #endif
1023                 if (ndevs>=MAX_DEVICES) {
1024                     die("More than %d hard disks are listed in '" PARTITIONS "'.\n"
1025                         "    Disks beyond the %dth must be marked:\n"
1026                         "        disk=" DEV_DISK_DIR "/XXXX  inaccessible\n"
1027                         "    in the configuration file (" DFL_CONFIG ").\n"
1028                         , MAX_DEVICES, MAX_DEVICES);
1029                 }
1030                 else
1031                 {
1032                     GEOMETRY geo;
1033
1034                     dev_open(&Dev2,dev,O_BYPASS);
1035
1036                     vm[ndevs].device = dev;
1037
1038                     vm[ndevs].sort = SORT(dev);
1039
1040                     vm[ndevs].vol_id.kernel = serial;
1041
1042                     vm[ndevs].name = stralloc(Dev2.name);
1043
1044                     if (verbose >= 4)
1045                         printf("pf:  dev=%04X  id=%08X  name=%s\n", dev, (int)serial, Dev2.name);
1046
1047                     for (walk = disktab; walk; walk = walk->next) {
1048                         if (walk->device == dev) {
1049                             bios = walk->bios;
1050                             vm[ndevs].dt = walk;        /* record disktab link */
1051                             if (bios >= 0x80 && bios <= DEV_MASK) {
1052                                 vm[ndevs].bios.actual =
1053                                         vm[ndevs].bios.user = bios;
1054                                 bios &= 0x7F;
1055                                 if (codes & (1L<<bios)) {
1056                                     i = ndevs-1;
1057                                     bios += 0x80;
1058                                     while (vm[i].bios.user != bios) i--;
1059                                     die("Disks '%s' and '%s' are both assigned 'bios=0x%02X'",
1060                                                 vm[ndevs].name, vm[i].name, bios);
1061                                 }
1062                                 codes |= 1L << bios;    /* mark BIOS code in use */
1063                             }
1064                             else if (bios != -1)
1065                                 die("Hard disk '%s' bios= specification out of the range [0x80..0x%02X]", Dev2.name, DEV_MASK);
1066
1067                             break;
1068                         }
1069                     }
1070
1071                     dev_close(&Dev2);
1072
1073                     geo_query_dev(&geo, dev,
1074                               MAJOR(dev)!=MAJOR_LOOP
1075 #ifdef LCF_ATARAID
1076                                && MAJOR(dev)!=MAJOR_DM
1077 #endif
1078                                                 );
1079
1080                     vm[ndevs].bios.probe = bios_device(&geo, dev);
1081
1082                     if (serial_valid(serial, DEV_MASK)) {
1083                         for (i=0; i<ndevs; i++) {
1084                             if (vm[i].vol_id.kernel==serial) {
1085                                 duplicate++;
1086                                 vm[i].flag |= DUPLICATE;
1087                                 vm[ndevs].flag |= DUPLICATE;    /* mark both of them */
1088                             } /* if */
1089                         } /* for */
1090                     }
1091                     else {
1092                         vm[ndevs].flag |= INVALID;
1093                         invalid++;
1094                     }
1095                     found = ++ndevs;
1096                 } /* if (open, lseek, read ) */
1097
1098             } /* if (!found)  */
1099
1100             if (ipart>0 && ipart<=PART_MAX) {
1101                 found--;
1102                 if (part_nowrite(name) & PTW_NTFS) {
1103                     vm[found].flag |= NTCAUTION;
1104                     vm[found].nt[ipart-1] = NTCAUTION;
1105                     ntcaution++;
1106                     if (verbose>=4) printf("NT partition: %s %d %s\n",
1107                                         vm[found].name, ipart, name);
1108                 }
1109             }
1110
1111         } /* if (mask && (device & P_MASK(device)) ) */
1112
1113     } /* while (!feof())  */
1114
1115     if (line) free(line);
1116     fclose(pp_fd);
1117
1118
1119
1120         if (verbose>=5) {
1121             int i;
1122             for (i=0; i<ndevs; i++)
1123                 printf("  %04X  %08X  %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1124         }
1125
1126     if (verbose>=2) printf("pf_hard_disk_scan: ndevs=%d\n", ndevs);
1127
1128 /* now sort the volumes into canonical order */
1129   {
1130         int i,j,k;
1131
1132         for (j=ndevs-1; j>0; j--)
1133         for (i=0; i<j; i++)
1134         if (vm[i].sort > vm[i+1].sort) {
1135             struct VolumeMgmt temp;
1136             temp = vm[i];
1137             vm[i] = vm[i+1];
1138             vm[i+1] = temp;
1139         }
1140
1141 /* now automatically treat MDP-RAID devices as inaccessible */
1142     for (k=0; k<ndevs; k++) {
1143 #ifdef LCF_MDPRAID
1144       if (MAJOR(vm[k].device) == MAJOR_MDP  ||
1145           MAJOR(vm[k].device) == MAJOR_EMD   ) {
1146
1147         if (verbose>=2) printf("MDP-RAID detected,   k=%d\n", k);
1148         if (cfg_get_flag(cf_options, "noraid") ) {
1149             raidcaution = 1;
1150             warn("RAID controller present, with \"noraid\" keyword used.\n"
1151                 "    Underlying drives individually must be marked INACCESSIBLE." );
1152         } else {
1153             for (j=0; j<ndevs; j++) {
1154                 if (j==k) break;        /* skip ourselves */
1155
1156                 if ((i=is_mdp(&vm[j], &vm[k]))<0) {
1157                     if (!identify) warn("(MDP-RAID driver) the kernel does not support underlying\n"
1158                         "    device inquiries.  Each underlying drive of  %s  must\n"
1159                         "    individually be marked INACCESSIBLE.", vm[k].name
1160                         );
1161                     j=ndevs;    /* terminate loop */
1162                 }
1163                 else if (i) {
1164                     if (!vm[j].dt) {
1165                         walk = alloc_t(DT_ENTRY);
1166                         walk->device = vm[j].device;
1167                         walk->cylinders = walk->heads = walk->sectors = walk->start = -1;
1168                         walk->next = disktab;
1169                         vm[j].dt = disktab = walk;
1170 #if BETA_TEST
1171                         if (verbose >= 4) printf("Allocated DT entry for device %04X  ptr=%08lx\n", vm[j].device, (long)walk);
1172 #endif
1173                     }
1174
1175                     if (vm[j].dt->heads != 0) {
1176                         vm[j].dt->heads = 0;
1177                         warn("(MDP-RAID) underlying device flagged INACCESSIBLE: %s",
1178                                 vm[j].name);
1179                     }
1180                     --ndevs;
1181                     warn("bypassing VolumeID check of underlying MDP-RAID drive:\n"
1182                         "\t%04X  %08X  %s",
1183                                 vm[j].device, vm[j].vol_id.kernel, vm[j].name);
1184                     for (i=j; i<ndevs; i++) vm[i] = vm[i+1];
1185                     if (j < k) k--;
1186                     j--;
1187                 }
1188             } /* for j   ... */
1189         }
1190       }
1191 #else
1192       if (MAJOR(vm[k].device) == MAJOR_EMD  ||
1193           MAJOR(vm[k].device) == MAJOR_MDP   ) {
1194           raidcaution = 1;
1195           warn("MDP-RAID controller present; underlying drives individually\n"
1196                 "    must be marked INACCESSIBLE." );
1197 #if BETA_TEST
1198 {
1199         int mdp_fd;
1200         DEVICE dev;
1201
1202         if ((mdp_fd=dev_open(&dev, vm[k].device, O_NOACCESS) ) < 0)
1203             die("Unable to open %s",vm[k].name);
1204
1205         dev_close(&dev);
1206 }
1207 #endif
1208       }
1209 #endif
1210 #ifdef LCF_ATARAID
1211       if ( MAJOR(vm[k].device) == MAJOR_DM ) {
1212           if (verbose>=2) printf("ATA-RAID detected,   k=%d\n", k);
1213           raidcaution = 1;
1214           warn("ATA-RAID controller present;\n"
1215               "    Underlying drives individually must be marked INACCESSIBLE." );
1216       }
1217 #endif
1218     } /* for (k ... */
1219   } /* end sort */
1220
1221         if (verbose>=3) {
1222             for (i=0; i<ndevs; i++)
1223                 printf("  %04X  %08X  %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1224             printf("Resolve invalid VolumeIDs\n");
1225         }
1226
1227 /* now go thru and resolve any invalid VolumeIDs */
1228
1229     if (invalid)
1230     for (i=0; i<ndevs; i++)
1231     if (vm[i].flag & INVALID) {
1232         if (ndevs>1) winnt_check(&vm[i], 1);
1233         else if (vm[i].flag & NTCAUTION) break;
1234
1235         dev = vm[i].device;
1236         vm[i].vol_id.kernel = volid_get_set(dev, new_serial(dev), ID_SET);
1237         vm[i].flag &= ~INVALID;
1238     }
1239
1240         if (verbose>=3)
1241             printf("Resolve duplicate VolumeIDs\n");
1242
1243 /* now check for duplicates */
1244
1245     while (duplicate) {         /* loop until there are none */
1246         int j, k;
1247
1248         if (raidcaution) {
1249             raidcaution = 0;    /* print comment only once */
1250             warn("Duplicated VolumeID's will be overwritten;\n"
1251                 "   With RAID present, this may defeat all boot redundancy.\n"
1252                 "   Underlying RAID-1 drives should be marked INACCESSIBLE.\n"
1253                 "   Check 'man lilo.conf' under 'disk=', 'inaccessible' option."
1254                 );
1255         }
1256         duplicate = 0;
1257         for (j=ndevs-1; j>0; j--) {
1258             for (i=0; i<j; i++) {
1259                 if (vm[i].vol_id.kernel == vm[j].vol_id.kernel) {
1260                     if (vm[i].flag & vm[j].flag & NTCAUTION) {
1261                         if (!winnt_check(&vm[j], 0)) k = j;
1262                         else winnt_check(&vm[k=i], 1);
1263                     }
1264                     else if (vm[i].flag & NTCAUTION) k = j;
1265                     else if (vm[j].flag & NTCAUTION) k = i;
1266                     else k = j;
1267
1268                     dev = vm[k].device;
1269                     vm[k].vol_id.kernel = volid_get_set(dev, new_serial(dev), ID_SET);
1270                     duplicate++;
1271                 }
1272             }
1273         }
1274     } /* while (duplicate) */
1275
1276
1277
1278         if (verbose>=2) {
1279             for (i=0; i<ndevs; i++)
1280                 printf("  %04X  %08X  %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1281         }
1282
1283
1284
1285     if (verbose>=2) printf("device codes (user assigned pf) = %lX\n", codes);
1286
1287 /* mark those BIOS codes that are already used in the disk=/bios= table */
1288
1289     for (walk=disktab; walk; walk=walk->next) {
1290         if (walk->bios >= 0x80) {   /* eliminate -1 and floppies */
1291             if (MAJOR(walk->device)==MAJOR_MD) continue;
1292             bios = walk->bios & 0x7F;
1293             if (bios >= 8*sizeof(codes) || bios >= MAX_BIOS_DEVICES)
1294                 die("BIOS code %02X is too big (device %04X)", bios+0x80, walk->device);
1295             if (codes & (1L<<bios)) {
1296                 int j = -1;
1297                 int k = -1;
1298
1299                 for (i=0; i<ndevs; i++) {
1300                     if (vm[i].device == walk->device) j = i;
1301                     else if (vm[i].bios.user == bios+0x80) k = i;
1302                 }
1303 #if BETA_TEST
1304                 if (verbose>=3) printf("J=%d  K=%d\n", j, k);
1305 #endif
1306                 if (j<0 && k>=0) {
1307                     die("Devices %04X and %04X are assigned to BIOS 0x%02X",
1308                         vm[k].device, walk->device, bios+0x80);
1309                 }
1310             }
1311             codes |= 1L << bios;
1312         }
1313     }
1314
1315     if (verbose>=2) printf("device codes (user assigned) = %lX\n", codes);
1316
1317     for (i=0; i<ndevs; i++) {
1318         bios = vm[i].bios.probe;
1319         if (bios >= 0x80) {
1320             if (vm[i].bios.actual < 0x80 && !(codes & (1L<<(bios&0x7F)))) {
1321                 vm[i].bios.actual = bios;
1322                 bios &= 0x7F;
1323                 codes |= 1L << bios;
1324             }
1325         }
1326     }
1327
1328     if (verbose>=2) printf("device codes (BIOS assigned) = %lX\n", codes);
1329
1330     for (bios=i=0; i<ndevs; i++) {
1331         int j;
1332
1333
1334         if (vm[i].bios.actual < 0x80) {
1335             while ( codes & (1L<<bios) ) bios++;
1336             if (bios < MAX_BIOS_DEVICES) {
1337                 codes |= 1L<<bios;
1338                 vm[i].bios.actual = 0x80+bios;
1339                 if (verbose>=3) printf("Filling in '%s' = 0x%02X\n", vm[i].name, bios+0x80);
1340             }
1341             else vm[i].bios.actual = -1;
1342         }
1343         if (!vm[i].dt) {
1344             walk = alloc_t(DT_ENTRY);
1345             walk->device = vm[i].device;
1346             walk->cylinders = walk->bios = walk->heads = walk->sectors = walk->start = -1;
1347             walk->next = disktab;
1348             vm[i].dt = disktab = walk;
1349 #if BETA_TEST
1350             if (verbose >= 4) printf("Allocated DT entry for device %04X  ptr=%08lx\n", vm[i].device, (long)walk);
1351 #endif
1352         }
1353         j = vm[i].dt->bios = vm[i].bios.actual;
1354         j &= 0x7F;
1355
1356         if (j < MAX_BIOS_DEVICES) {
1357             serial_no[j] = vm[i].vol_id.kernel;
1358             device_code[j] = vm[i].device;
1359 #if BETA_TEST
1360             if (verbose >= 5) {
1361                 printf("Generated: %02X  %04X  %08X\n", j+0x80, device_code[j], (int)serial_no[j]);
1362             }
1363 #endif
1364         }
1365         else {
1366             vm[i].dt->heads = 0;        /* mark inaccessible */
1367             {
1368                 static int i=0;
1369                 if (!(i++)) warn("Internal implementation restriction. Boot may occur from the first\n"
1370                     "    %d disks only. Disks beyond the %dth will be flagged INACCESSIBLE."
1371                     , MAX_BIOS_DEVICES, MAX_BIOS_DEVICES);
1372                 warn("'disk=%s  inaccessible' is being assumed.  (%04X)",
1373                 vm[i].name, vm[i].device);
1374             }
1375         }
1376
1377         inited = 1;
1378     }
1379
1380     if (verbose>=2) printf("device codes (canonical) = %lX\n", codes);
1381
1382     for (bios=8*sizeof(codes)-1; !(codes&(1L<<bios)) && bios>=0; ) bios--;
1383
1384     if (bios > ndevs)
1385         warn("BIOS device code 0x%02X is used (>0x%02X).  It indicates more disks\n"
1386                         "  than those represented in '/proc/partitions' having actual partitions.\n"
1387                         "  Booting results may be unpredictable.", bios+0x80, ndevs+0x80-1);
1388
1389
1390
1391     return ret;
1392 }
1393