1 /* device.c - Device access */
3 Copyright 1992-1997 Werner Almesberger.
4 Copyright 1999-2006 John Coffman.
7 Licensed under the terms contained in the file 'COPYING' in the
22 #include <sys/types.h>
32 #include "partition.h"
38 typedef struct _cache_entry {
41 struct _cache_entry *next;
44 typedef struct _st_buf {
50 static CACHE_ENTRY *cache = NULL;
54 int yesno(char *prompt, int expect)
60 if (expect) pr2 = "[Y/n]";
65 fprintf(stderr, "%s%s", prompt, pr2);
69 i = getline(&line, &n, stdin);
71 if (i==1) ret=expect|2;
73 if (*line=='y'||*line=='Y') ret=1;
74 if (*line=='n'||*line=='N') ret=2;
84 static int scan_dir(ST_BUF *next,DEVICE *dev,char *parent,int number)
91 if (verbose >= 5) printf("scan_dir: %s\n", parent);
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) {
100 if (S_ISBLK(dev->st.st_mode) && dev->st.st_rdev == number) {
105 if (S_ISDIR(dev->st.st_mode) && strcmp(dir->d_name,".") &&
106 strcmp(dir->d_name,"..")) {
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")) {
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)) {
127 static int lookup_dev(char *name,DEVICE *dev,int number)
131 if (verbose>=5) printf("lookup_dev: number=%04X\n", number);
132 for (walk = &cache; *walk; walk = &(*walk)->next)
133 if ((*walk)->number == number) {
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);
142 here = *walk; /* remove entry from cache */
144 printf("Invalidating cache entry for %s (0x%04X)\n",here->name,
147 free((char *) here->name);
151 strcpy(name,(*walk)->name);
159 static int is_devfs(void)
161 static int yesno = 0;
165 if (stat(DEV_DIR "/.devfsd", &st) < 0) yesno=1;
174 static void cache_add(const char *name,int number)
180 if (strcmp(entry->name, name) == 0) {
181 if (entry->number != number) die("cache_add: LILO internal error");
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;
195 int dev_open(DEVICE *dev,int number,int flags)
202 if (lookup_dev(name,dev,number)) dev->delete = 0;
204 if (stat(DEV_DIR,&st.st) < 0)
205 die("stat " DEV_DIR ": %s",strerror(errno));
207 dev->delete = !scan_dir(&st,dev,strcpy(name,DEV_DIR),number);
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);
217 sprintf(name,TMP_DEV,count);
218 if (stat(name,&dev->st) < 0) break;
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));
227 printf("Created temporary device %s (0x%04X)\n",name,number);
230 else cache_add(name,number);
233 if (verbose >= 4) printf("stat-ing %s\n", name);
237 if (flags == O_BYPASS) dev->fd = -1;
238 else if ((dev->fd = open(name,flags)) < 0) {
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));
246 dev->name = stralloc(name);
251 void dev_close(DEVICE *dev)
254 if (close(dev->fd) < 0) die("close %s: %s",dev->name,strerror(errno));
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);
267 void cache_scsi (char *name, int major)
269 char tem[PATH_MAX], format[PATH_MAX];
271 int k = strlen(DEV_DISK_DIR) + 3;
273 for (i=15; i>=0; i--) {
274 dev = MKDEV(major,(i<<4));
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");
285 strcpy(format, name);
287 cache_add(format, dev);
288 strcat(format, "%d");
290 for (j = MAX; j; j--) {
291 sprintf(tem, format, j);
292 cache_add(tem, dev | j);
298 void cache_ide (char *name, int major)
300 char tem[PATH_MAX], tem2[PATH_MAX];
301 char format[PATH_MAX];
303 int i, dev, minor, host, bus, target;
304 int j = strlen(DEV_DISK_DIR) + 3;
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");
318 strcat(strcpy(format, name), "%d");
321 dev = MKDEV(major,minor);
322 for (i = MAX; i; i--) {
323 sprintf(tem, format, i);
324 cache_add(tem, dev | i);
326 cache_add(disc, dev);
329 void preload_dev_cache(void)
338 if (verbose>0) verbose--;
342 cache_add(DEV_DIR "/floppy/0", 0x0200);
343 cache_add(DEV_DIR "/floppy/1", 0x0201);
346 cache_add(DEV_DIR "/fd0", 0x0200);
347 cache_add(DEV_DIR "/fd1", 0x0201);
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);
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);
361 cache_ide(DEV_DISK_DIR "/hdl", MAJOR_IDE6);
362 cache_ide(DEV_DISK_DIR "/hdk", MAJOR_IDE6);
364 cache_ide(DEV_DISK_DIR "/hdj", MAJOR_IDE5);
365 cache_ide(DEV_DISK_DIR "/hdi", MAJOR_IDE5);
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));
374 if (!is_devfs()) cache_scsi(DEV_DISK_DIR "/sda", MAJOR_SD);
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);
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);
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);
397 static unsigned int idevices[NDEVICE];
398 static int maxdev = 0;
400 /* return 0 if device has not been backed up, */
401 /* 1 if it has been backed up */
403 static int dev_listed(unsigned short dev)
407 /* scan the device list */
408 for (i=0; i<maxdev; i++) {
409 if (dev==idevices[i]) return 1; /* already backed up */
412 if (maxdev < NDEVICE-1) idevices[maxdev++] = dev;
414 return 0; /* new to the list, not listed if too many devices */
418 /* make a backup, returning the timestamp of the backup file */
419 /* 0 if no timestamp returned, and no backup file created */
421 int make_backup(char *backup_file, int force_backup, BOOT_SECTOR *bsect,
422 unsigned int device, char *id)
425 char temp_name[PATH_MAX];
428 char *filename = "boot";
434 if ((cp=cfg_get_strg(cf_options,"force-backup"))) force=1;
435 else cp=cfg_get_strg(cf_options,"backup");
438 force_backup = force;
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;
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);
454 /* could not stat it, or it was a directory, or it was a regular file */
457 char *name, *dir, suffix[16];
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);
469 else if (name[1]==0) strcat(name,suffix); /* ended with '.' */
472 strcat(backup_file,suffix);
474 /* we now have the filename with the correct suffix */
477 /* no '.' in the name, take it as a template */
478 strcat(backup_file,".");
479 strcat(backup_file,suffix);
483 /* if (!backup_file) */ {
484 sprintf(temp_name, BACKUP_DIR "/%s.%04X", filename, device);
485 backup_file = temp_name;
488 bck_file = open(backup_file, O_RDONLY);
489 if (bck_file >= 0 && force_backup) {
490 (void) close(bck_file);
495 printf("%s exists - no %s backup copy made.\n", backup_file, id);
498 if (dev_listed(device)) {
500 printf("Backup copy of %s has already been made in %s\n",
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));
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;
516 printf("Backup copy of %s in %s (test mode)\n", id, backup_file);
519 if (bck_file >= 0 && close(bck_file) < 0) die("close %s: %s",backup_file,strerror(errno));
527 int serial_valid(unsigned int serial, int disk_bios)
530 return (serial != 0);
532 if (serial == -1 || serial == 0) return 0;
535 /* if ID is replicated characters, it is invalid */
536 /* Examples of invalid Volume ID's are:
540 BUT: any Volume ID (except 0 or -1) is valid on drive C:
541 - - - - - - - - - - - - - - - - - - - - - - - - - - */
544 temp = serial & 0xFF;
548 return (serial != temp ||
549 (serial!=0 && serial!=0xFFFFFFFFUL && disk_bios==0x80));
553 int new_serial(int dev)
555 static int inited = 0;
560 #define RANDOM DEV_DIR "/urandom"
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) ) {
567 if(verbose>=5) printf("Using " RANDOM " for seeding random number generator\n");
575 dev = dev % PRIME + SMALL_PRIME;
576 while(dev--) inited = rand();
585 static int inited = 0;
586 unsigned int serial_no[MAX_BIOS_DEVICES];
587 static int device_code[MAX_BIOS_DEVICES];
589 /* register references to various bios devices
590 * compiles the list of volume IDs
591 * returns volume ID on success
595 unsigned int register_bios(int bios, int device)
597 int i, fd, valid, disk_bios;
600 unsigned int serial = -1;
604 for (i=0; i<MAX_BIOS_DEVICES; i++) {
614 if (!do_md_install && cfg_get_flag(cf_options, "static-bios-codes")) return 0;
617 printf("registering bios=0x%02X device=0x%04X\n", bios, device);
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");
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");
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;
646 printf("Assigning new Volume ID to (%04X) '%s' ID = %08X\n",
647 device, dev.name, (int)serial);
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));
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);
662 device_code[bios] = device;
663 serial_no[bios] = serial;
667 if (device_code[bios]==device) serial = serial_no[bios];
671 dev_open(&dev, device_code[bios], O_BYPASS);
672 dev_open(&deva, device, O_BYPASS);
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);
678 printf("Using Volume ID %08X on bios %02X\n", (int)serial, bios+0x80);
681 else if (bios>=0 && bios <=3) serial = 0;
688 void dump_serial_nos(void)
692 printf(" BIOS VolumeID Device\n");
694 for (j=nelem(serial_no); serial_no[--j]==0; ) ;
696 printf(" %02X %08X %04X\n",
704 enum {ID_GET=0, ID_SET};
706 static int volid_get_set(int device, int vol_in, int option)
714 if (!has_partitions(device) && (device & P_MASK(device)) )
715 die("VolumeID set/get bad device %04X\n", device);
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);
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 */
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;
737 buf.boot.volume_id = vol_in;
738 if (buf.boot.marker == 0) buf.boot.marker = MAGIC_SERIAL;
740 if (lseek(fd, 0L, SEEK_SET) != 0L ||
741 write(fd, &buf, PART_TABLE_OFFSET) != PART_TABLE_OFFSET )
742 die("volid write error");
746 sync(); /* critical that this be done here */
748 return buf.boot.volume_id;
754 /* count the number of slashes in a pathname */
755 static int slashes(char *cp)
759 while ( (cp=strchr(++cp,'/')) ) n++;
766 enum {INVALID=1, DUPLICATE=2, REGENERATE=3, NTCAUTION=4};
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 */
776 int kernel; /* volume ID as read using kernel I/O */
777 int probe; /* volume ID as probed */
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 */
788 /* return boolean if VM is a component drive of MDP-RAID */
790 static int is_mdp(struct VolumeMgmt *vm, struct VolumeMgmt *mdp)
794 struct md_version md_version_info;
795 md_array_info_t raid;
798 if (verbose>=2) printf("is_mdp: %04X : %04X\n",
799 vm->device, mdp->device);
801 if ((mdp_fd=dev_open(&dev, mdp->device, O_NOACCESS) ) < 0)
802 die("Unable to open %s", mdp->name);
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) {
809 warn("RAID versions other than 0.90 are not supported");
811 else if (ioctl(mdp_fd, GET_ARRAY_INFO, &raid) < 0) ret = -1;
812 else if (raid.level == 1) {
816 for (i=0; ret==0 && i<raid.active_disks; i++) {
818 if (ioctl(mdp_fd, GET_DISK_INFO, &disk) < 0) ret = -1;
819 if (vm->device == MKDEV(disk.major, disk.minor)) ret = 1;
822 /* else ret = 0; already */
825 if (verbose>=2) printf("is_mdp: returns %d\n", ret);
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
835 static int winnt_check(struct VolumeMgmt *vm, int fatal)
839 if ( !(vm->flag & NTCAUTION) ) return 0;
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);
853 ret = yesno("\nIs the above disk an NT boot disk? ", 1);
856 fprintf(stderr, "Aborting ...\n");
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)):\
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)):\
878 int pf_hard_disk_scan(void)
880 struct VolumeMgmt vm [MAX_DEVICES];
881 static int warned = 0, called = 0;
882 char *line, *next, *name;
883 int major, minor, i, ipart;
890 int duplicate = 0, invalid = 0, ret = 0, ntcaution = 0;
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;
898 memset(vm,0,sizeof(vm)); /* for consistency */
901 if (!pp_fd && (pp_fd = fopen(PARTITIONS, "r"))==NULL) {
903 if ((pp_fd = fopen(PARTITIONS, "r"))==NULL || fetch()) {
905 warn("'" PARTITIONS "' does not exist, disk scan bypassed");
911 while (!feof(pp_fd)) {
917 if (getline(&line, &n, pp_fd) <= 0) break;
919 major = strtoul(line, &next, 10);
920 if (major==0 || line==next) continue;
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);
929 else if ((major>=60 && major<=63) || (major>=120 && major<=127) ) {
930 warn(PARTITIONS " references Experimental major device %d.", major);
932 else if (major==255) {
933 warn(PARTITIONS " references Reserved device 255.");
936 else if (major>=240 && major<255) {
937 warn(PARTITIONS " references Experimental major device %d.", major);
940 minor = strtoul(next, &name, 10);
941 if (next==name) continue;
942 /* skip */ strtoull(name,&next,10);
944 while (isspace(*next)) next++;
946 while (*name && !isspace(*name)) name++;
948 if (strncmp(DEV_DISK_DIR "/", next, strlen(DEV_DISK_DIR)+1) != 0) name = next-(strlen(DEV_DISK_DIR)+1);
950 if (*name=='/') name++;
951 strncpy(name, DEV_DISK_DIR "/", strlen(DEV_DISK_DIR)+1);
953 printf("pf_hard_disk_scan: (%d,%d) %s\n", major, minor, name);
956 device = MKDEV(major, minor);
959 if (stat(name, &st) < 0) {
960 dev_open(&Dev, device, O_BYPASS);
962 warn("'" PARTITIONS "' does not match '" DEV_DISK_DIR "' directory structure.\n"
963 " Name change: '%s' -> '%s'%s"
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."
978 warn("Name change: '%s' -> '%s'", name, Dev.name);
982 warn("'" DEV_DISK_DIR "' directory structure is incomplete; device (%d, %d) is missing.",
984 cache_add(name, device);
987 else cache_add(name, device);
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 */
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 */
1005 if (mask && ipart>0) {
1009 for (found=i=0; i<ndevs && !found; i++) {
1010 if (dev==vm[i].device) found = i+1;
1014 serial = volid_get_set(dev, 0, ID_GET);
1017 /* take care of uninitialized Volume IDs with no fanfare */
1019 serial = volid_get_set(dev, new_serial(dev), ID_SET);
1023 if (verbose>=3) printf("**ndevs=%d\n", ndevs);
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);
1036 dev_open(&Dev2,dev,O_BYPASS);
1038 vm[ndevs].device = dev;
1040 vm[ndevs].sort = SORT(dev);
1042 vm[ndevs].vol_id.kernel = serial;
1044 vm[ndevs].name = stralloc(Dev2.name);
1047 printf("pf: dev=%04X id=%08X name=%s\n", dev, (int)serial, Dev2.name);
1049 for (walk = disktab; walk; walk = walk->next) {
1050 if (walk->device == dev) {
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;
1057 if (codes & (1L<<bios)) {
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);
1064 codes |= 1L << bios; /* mark BIOS code in use */
1066 else if (bios != -1)
1067 die("Hard disk '%s' bios= specification out of the range [0x80..0x%02X]", Dev2.name, DEV_MASK);
1075 geo_query_dev(&geo, dev,
1076 MAJOR(dev)!=MAJOR_LOOP
1078 && MAJOR(dev)!=MAJOR_DM
1082 vm[ndevs].bios.probe = bios_device(&geo, dev);
1084 if (serial_valid(serial, DEV_MASK)) {
1085 for (i=0; i<ndevs; i++) {
1086 if (vm[i].vol_id.kernel==serial) {
1088 vm[i].flag |= DUPLICATE;
1089 vm[ndevs].flag |= DUPLICATE; /* mark both of them */
1094 vm[ndevs].flag |= INVALID;
1098 } /* if (open, lseek, read ) */
1102 if (ipart>0 && ipart<=PART_MAX) {
1104 if (part_nowrite(name) & PTW_NTFS) {
1105 vm[found].flag |= NTCAUTION;
1106 vm[found].nt[ipart-1] = NTCAUTION;
1108 if (verbose>=4) printf("NT partition: %s %d %s\n",
1109 vm[found].name, ipart, name);
1113 } /* if (mask && (device & P_MASK(device)) ) */
1115 } /* while (!feof()) */
1117 if (line) free(line);
1124 for (i=0; i<ndevs; i++)
1125 printf(" %04X %08X %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1128 if (verbose>=2) printf("pf_hard_disk_scan: ndevs=%d\n", ndevs);
1130 /* now sort the volumes into canonical order */
1134 for (j=ndevs-1; j>0; j--)
1136 if (vm[i].sort > vm[i+1].sort) {
1137 struct VolumeMgmt temp;
1143 /* now automatically treat MDP-RAID devices as inaccessible */
1144 for (k=0; k<ndevs; k++) {
1146 if (MAJOR(vm[k].device) == MAJOR_MDP ||
1147 MAJOR(vm[k].device) == MAJOR_EMD ) {
1149 if (verbose>=2) printf("MDP-RAID detected, k=%d\n", k);
1150 if (cfg_get_flag(cf_options, "noraid") ) {
1152 warn("RAID controller present, with \"noraid\" keyword used.\n"
1153 " Underlying drives individually must be marked INACCESSIBLE." );
1155 for (j=0; j<ndevs; j++) {
1156 if (j==k) break; /* skip ourselves */
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
1163 j=ndevs; /* terminate loop */
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;
1173 if (verbose >= 4) printf("Allocated DT entry for device %04X ptr=%08lx\n", vm[j].device, (long)walk);
1177 if (vm[j].dt->heads != 0) {
1178 vm[j].dt->heads = 0;
1179 warn("(MDP-RAID) underlying device flagged INACCESSIBLE: %s",
1183 warn("bypassing VolumeID check of underlying MDP-RAID drive:\n"
1185 vm[j].device, vm[j].vol_id.kernel, vm[j].name);
1186 for (i=j; i<ndevs; i++) vm[i] = vm[i+1];
1194 if (MAJOR(vm[k].device) == MAJOR_EMD ||
1195 MAJOR(vm[k].device) == MAJOR_MDP ) {
1197 warn("MDP-RAID controller present; underlying drives individually\n"
1198 " must be marked INACCESSIBLE." );
1204 if ((mdp_fd=dev_open(&dev, vm[k].device, O_NOACCESS) ) < 0)
1205 die("Unable to open %s",vm[k].name);
1213 if ( MAJOR(vm[k].device) == MAJOR_DM ) {
1214 if (verbose>=2) printf("ATA-RAID detected, k=%d\n", k);
1216 warn("ATA-RAID controller present;\n"
1217 " Underlying drives individually must be marked INACCESSIBLE." );
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");
1229 /* now go thru and resolve any invalid VolumeIDs */
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;
1238 vm[i].vol_id.kernel = volid_get_set(dev, new_serial(dev), ID_SET);
1239 vm[i].flag &= ~INVALID;
1243 printf("Resolve duplicate VolumeIDs\n");
1245 /* now check for duplicates */
1247 while (duplicate) { /* loop until there are none */
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."
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);
1266 else if (vm[i].flag & NTCAUTION) k = j;
1267 else if (vm[j].flag & NTCAUTION) k = i;
1271 vm[k].vol_id.kernel = volid_get_set(dev, new_serial(dev), ID_SET);
1276 } /* while (duplicate) */
1281 for (i=0; i<ndevs; i++)
1282 printf(" %04X %08X %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1287 if (verbose>=2) printf("device codes (user assigned pf) = %lX\n", codes);
1289 /* mark those BIOS codes that are already used in the disk=/bios= table */
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)) {
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;
1306 if (verbose>=3) printf("J=%d K=%d\n", j, k);
1309 die("Devices %04X and %04X are assigned to BIOS 0x%02X",
1310 vm[k].device, walk->device, bios+0x80);
1313 codes |= 1L << bios;
1317 if (verbose>=2) printf("device codes (user assigned) = %lX\n", codes);
1319 for (i=0; i<ndevs; i++) {
1320 bios = vm[i].bios.probe;
1322 if (vm[i].bios.actual < 0x80 && !(codes & (1L<<(bios&0x7F)))) {
1323 vm[i].bios.actual = bios;
1325 codes |= 1L << bios;
1330 if (verbose>=2) printf("device codes (BIOS assigned) = %lX\n", codes);
1332 for (bios=i=0; i<ndevs; i++) {
1336 if (vm[i].bios.actual < 0x80) {
1337 while ( codes & (1L<<bios) ) bios++;
1338 if (bios < MAX_BIOS_DEVICES) {
1340 vm[i].bios.actual = 0x80+bios;
1341 if (verbose>=3) printf("Filling in '%s' = 0x%02X\n", vm[i].name, bios+0x80);
1343 else vm[i].bios.actual = -1;
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;
1352 if (verbose >= 4) printf("Allocated DT entry for device %04X ptr=%08lx\n", vm[i].device, (long)walk);
1355 j = vm[i].dt->bios = vm[i].bios.actual;
1358 if (j < MAX_BIOS_DEVICES) {
1359 serial_no[j] = vm[i].vol_id.kernel;
1360 device_code[j] = vm[i].device;
1363 printf("Generated: %02X %04X %08X\n", j+0x80, device_code[j], (int)serial_no[j]);
1368 vm[i].dt->heads = 0; /* mark inaccessible */
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);
1382 if (verbose>=2) printf("device codes (canonical) = %lX\n", codes);
1384 for (bios=8*sizeof(codes)-1; !(codes&(1L<<bios)) && bios>=0; ) bios--;
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);