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