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)
201 if (lookup_dev(name,dev,number)) dev->delete = 0;
203 if (stat(DEV_DIR,&st.st) < 0)
204 die("stat " DEV_DIR ": %s",strerror(errno));
206 dev->delete = !scan_dir(&st,dev,strcpy(name,DEV_DIR),number);
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);
216 sprintf(name,TMP_DEV,count);
217 if (stat(name,&dev->st) < 0) break;
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));
226 printf("Created temporary device %s (0x%04X)\n",name,number);
229 else cache_add(name,number);
232 if (verbose >= 4) printf("stat-ing %s\n", name);
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));
244 dev->name = stralloc(name);
249 void dev_close(DEVICE *dev)
252 if (close(dev->fd) < 0) die("close %s: %s",dev->name,strerror(errno));
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);
265 void cache_scsi (char *name, int major)
267 char tem[PATH_MAX], format[PATH_MAX];
269 int k = strlen(DEV_DISK_DIR) + 3;
271 for (i=15; i>=0; i--) {
272 dev = MKDEV(major,(i<<4));
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");
283 strcpy(format, name);
285 cache_add(format, dev);
286 strcat(format, "%d");
288 for (j = MAX; j; j--) {
289 sprintf(tem, format, j);
290 cache_add(tem, dev | j);
296 void cache_ide (char *name, int major)
298 char tem[PATH_MAX], tem2[PATH_MAX];
299 char format[PATH_MAX];
301 int i, dev, minor, host, bus, target;
302 int j = strlen(DEV_DISK_DIR) + 3;
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");
316 strcat(strcpy(format, name), "%d");
319 dev = MKDEV(major,minor);
320 for (i = MAX; i; i--) {
321 sprintf(tem, format, i);
322 cache_add(tem, dev | i);
324 cache_add(disc, dev);
327 void preload_dev_cache(void)
336 if (verbose>0) verbose--;
340 cache_add(DEV_DIR "/floppy/0", 0x0200);
341 cache_add(DEV_DIR "/floppy/1", 0x0201);
344 cache_add(DEV_DIR "/fd0", 0x0200);
345 cache_add(DEV_DIR "/fd1", 0x0201);
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);
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);
359 cache_ide(DEV_DISK_DIR "/hdl", MAJOR_IDE6);
360 cache_ide(DEV_DISK_DIR "/hdk", MAJOR_IDE6);
362 cache_ide(DEV_DISK_DIR "/hdj", MAJOR_IDE5);
363 cache_ide(DEV_DISK_DIR "/hdi", MAJOR_IDE5);
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));
372 if (!is_devfs()) cache_scsi(DEV_DISK_DIR "/sda", MAJOR_SD);
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);
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);
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);
395 static unsigned int idevices[NDEVICE];
396 static int maxdev = 0;
398 /* return 0 if device has not been backed up, */
399 /* 1 if it has been backed up */
401 static int dev_listed(unsigned short dev)
405 /* scan the device list */
406 for (i=0; i<maxdev; i++) {
407 if (dev==idevices[i]) return 1; /* already backed up */
410 if (maxdev < NDEVICE-1) idevices[maxdev++] = dev;
412 return 0; /* new to the list, not listed if too many devices */
416 /* make a backup, returning the timestamp of the backup file */
417 /* 0 if no timestamp returned, and no backup file created */
419 int make_backup(char *backup_file, int force_backup, BOOT_SECTOR *bsect,
420 unsigned int device, char *id)
423 char temp_name[PATH_MAX];
426 char *filename = "boot";
432 if ((cp=cfg_get_strg(cf_options,"force-backup"))) force=1;
433 else cp=cfg_get_strg(cf_options,"backup");
436 force_backup = force;
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;
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);
452 /* could not stat it, or it was a directory, or it was a regular file */
455 char *name, *dir, suffix[16];
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);
467 else if (name[1]==0) strcat(name,suffix); /* ended with '.' */
470 strcat(backup_file,suffix);
472 /* we now have the filename with the correct suffix */
475 /* no '.' in the name, take it as a template */
476 strcat(backup_file,".");
477 strcat(backup_file,suffix);
481 /* if (!backup_file) */ {
482 sprintf(temp_name, BACKUP_DIR "/%s.%04X", filename, device);
483 backup_file = temp_name;
486 bck_file = open(backup_file, O_RDONLY);
487 if (bck_file >= 0 && force_backup) {
488 (void) close(bck_file);
493 printf("%s exists - no %s backup copy made.\n", backup_file, id);
496 if (dev_listed(device)) {
498 printf("Backup copy of %s has already been made in %s\n",
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));
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;
514 printf("Backup copy of %s in %s (test mode)\n", id, backup_file);
517 if (bck_file >= 0 && close(bck_file) < 0) die("close %s: %s",backup_file,strerror(errno));
525 int serial_valid(unsigned int serial, int disk_bios)
528 return (serial != 0);
530 if (serial == -1 || serial == 0) return 0;
533 /* if ID is replicated characters, it is invalid */
534 /* Examples of invalid Volume ID's are:
538 BUT: any Volume ID (except 0 or -1) is valid on drive C:
539 - - - - - - - - - - - - - - - - - - - - - - - - - - */
542 temp = serial & 0xFF;
546 return (serial != temp ||
547 (serial!=0 && serial!=0xFFFFFFFFUL && disk_bios==0x80));
551 int new_serial(int dev)
553 static int inited = 0;
558 #define RANDOM DEV_DIR "/urandom"
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) ) {
565 if(verbose>=5) printf("Using " RANDOM " for seeding random number generator\n");
573 dev = dev % PRIME + SMALL_PRIME;
574 while(dev--) inited = rand();
583 static int inited = 0;
584 unsigned int serial_no[MAX_BIOS_DEVICES];
585 static int device_code[MAX_BIOS_DEVICES];
587 /* register references to various bios devices
588 * compiles the list of volume IDs
589 * returns volume ID on success
593 unsigned int register_bios(int bios, int device)
595 int i, fd, valid, disk_bios;
598 unsigned int serial = -1;
602 for (i=0; i<MAX_BIOS_DEVICES; i++) {
612 if (!do_md_install && cfg_get_flag(cf_options, "static-bios-codes")) return 0;
615 printf("registering bios=0x%02X device=0x%04X\n", bios, device);
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");
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");
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;
644 printf("Assigning new Volume ID to (%04X) '%s' ID = %08X\n",
645 device, dev.name, (int)serial);
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));
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);
660 device_code[bios] = device;
661 serial_no[bios] = serial;
665 if (device_code[bios]==device) serial = serial_no[bios];
669 dev_open(&dev, device_code[bios], O_BYPASS);
670 dev_open(&deva, device, O_BYPASS);
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);
676 printf("Using Volume ID %08X on bios %02X\n", (int)serial, bios+0x80);
679 else if (bios>=0 && bios <=3) serial = 0;
686 void dump_serial_nos(void)
690 printf(" BIOS VolumeID Device\n");
692 for (j=nelem(serial_no); serial_no[--j]==0; ) ;
694 printf(" %02X %08X %04X\n",
702 enum {ID_GET=0, ID_SET};
704 static int volid_get_set(int device, int vol_in, int option)
712 if (!has_partitions(device) && (device & P_MASK(device)) )
713 die("VolumeID set/get bad device %04X\n", device);
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);
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 */
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;
735 buf.boot.volume_id = vol_in;
736 if (buf.boot.marker == 0) buf.boot.marker = MAGIC_SERIAL;
738 if (lseek(fd, 0L, SEEK_SET) != 0L ||
739 write(fd, &buf, PART_TABLE_OFFSET) != PART_TABLE_OFFSET )
740 die("volid write error");
744 sync(); /* critical that this be done here */
746 return buf.boot.volume_id;
752 /* count the number of slashes in a pathname */
753 static int slashes(char *cp)
757 while ( (cp=strchr(++cp,'/')) ) n++;
764 enum {INVALID=1, DUPLICATE=2, REGENERATE=3, NTCAUTION=4};
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 */
774 int kernel; /* volume ID as read using kernel I/O */
775 int probe; /* volume ID as probed */
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 */
786 /* return boolean if VM is a component drive of MDP-RAID */
788 static int is_mdp(struct VolumeMgmt *vm, struct VolumeMgmt *mdp)
792 struct md_version md_version_info;
793 md_array_info_t raid;
796 if (verbose>=2) printf("is_mdp: %04X : %04X\n",
797 vm->device, mdp->device);
799 if ((mdp_fd=dev_open(&dev, mdp->device, O_NOACCESS) ) < 0)
800 die("Unable to open %s", mdp->name);
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) {
807 warn("RAID versions other than 0.90 are not supported");
809 else if (ioctl(mdp_fd, GET_ARRAY_INFO, &raid) < 0) ret = -1;
810 else if (raid.level == 1) {
814 for (i=0; ret==0 && i<raid.active_disks; i++) {
816 if (ioctl(mdp_fd, GET_DISK_INFO, &disk) < 0) ret = -1;
817 if (vm->device == MKDEV(disk.major, disk.minor)) ret = 1;
820 /* else ret = 0; already */
823 if (verbose>=2) printf("is_mdp: returns %d\n", ret);
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
833 static int winnt_check(struct VolumeMgmt *vm, int fatal)
837 if ( !(vm->flag & NTCAUTION) ) return 0;
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);
851 ret = yesno("\nIs the above disk an NT boot disk? ", 1);
854 fprintf(stderr, "Aborting ...\n");
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)):\
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)):\
876 int pf_hard_disk_scan(void)
878 struct VolumeMgmt vm [MAX_DEVICES];
879 static int warned = 0, called = 0;
880 char *line, *next, *name;
881 int major, minor, i, ipart;
888 int duplicate = 0, invalid = 0, ret = 0, ntcaution = 0;
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;
896 memset(vm,0,sizeof(vm)); /* for consistency */
899 if (!pp_fd && (pp_fd = fopen(PARTITIONS, "r"))==NULL) {
901 if ((pp_fd = fopen(PARTITIONS, "r"))==NULL || fetch()) {
903 warn("'" PARTITIONS "' does not exist, disk scan bypassed");
909 while (!feof(pp_fd)) {
915 if (getline(&line, &n, pp_fd) <= 0) break;
917 major = strtoul(line, &next, 10);
918 if (major==0 || line==next) continue;
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);
927 else if ((major>=60 && major<=63) || (major>=120 && major<=127) ) {
928 warn(PARTITIONS " references Experimental major device %d.", major);
930 else if (major==255) {
931 warn(PARTITIONS " references Reserved device 255.");
934 else if (major>=240 && major<255) {
935 warn(PARTITIONS " references Experimental major device %d.", major);
938 minor = strtoul(next, &name, 10);
939 if (next==name) continue;
940 /* skip */ strtoull(name,&next,10);
942 while (isspace(*next)) next++;
944 while (*name && !isspace(*name)) name++;
946 if (strncmp(DEV_DISK_DIR "/", next, strlen(DEV_DISK_DIR)+1) != 0) name = next-(strlen(DEV_DISK_DIR)+1);
948 if (*name=='/') name++;
949 strncpy(name, DEV_DISK_DIR "/", strlen(DEV_DISK_DIR)+1);
951 printf("pf_hard_disk_scan: (%d,%d) %s\n", major, minor, name);
954 device = MKDEV(major, minor);
957 if (stat(name, &st) < 0) {
958 dev_open(&Dev, device, O_BYPASS);
960 warn("'" PARTITIONS "' does not match '" DEV_DISK_DIR "' directory structure.\n"
961 " Name change: '%s' -> '%s'%s"
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."
976 warn("Name change: '%s' -> '%s'", name, Dev.name);
980 warn("'" DEV_DISK_DIR "' directory structure is incomplete; device (%d, %d) is missing.",
982 cache_add(name, device);
985 else cache_add(name, device);
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 */
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 */
1003 if (mask && ipart>0) {
1007 for (found=i=0; i<ndevs && !found; i++) {
1008 if (dev==vm[i].device) found = i+1;
1012 serial = volid_get_set(dev, 0, ID_GET);
1015 /* take care of uninitialized Volume IDs with no fanfare */
1017 serial = volid_get_set(dev, new_serial(dev), ID_SET);
1021 if (verbose>=3) printf("**ndevs=%d\n", ndevs);
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);
1034 dev_open(&Dev2,dev,O_BYPASS);
1036 vm[ndevs].device = dev;
1038 vm[ndevs].sort = SORT(dev);
1040 vm[ndevs].vol_id.kernel = serial;
1042 vm[ndevs].name = stralloc(Dev2.name);
1045 printf("pf: dev=%04X id=%08X name=%s\n", dev, (int)serial, Dev2.name);
1047 for (walk = disktab; walk; walk = walk->next) {
1048 if (walk->device == dev) {
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;
1055 if (codes & (1L<<bios)) {
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);
1062 codes |= 1L << bios; /* mark BIOS code in use */
1064 else if (bios != -1)
1065 die("Hard disk '%s' bios= specification out of the range [0x80..0x%02X]", Dev2.name, DEV_MASK);
1073 geo_query_dev(&geo, dev,
1074 MAJOR(dev)!=MAJOR_LOOP
1076 && MAJOR(dev)!=MAJOR_DM
1080 vm[ndevs].bios.probe = bios_device(&geo, dev);
1082 if (serial_valid(serial, DEV_MASK)) {
1083 for (i=0; i<ndevs; i++) {
1084 if (vm[i].vol_id.kernel==serial) {
1086 vm[i].flag |= DUPLICATE;
1087 vm[ndevs].flag |= DUPLICATE; /* mark both of them */
1092 vm[ndevs].flag |= INVALID;
1096 } /* if (open, lseek, read ) */
1100 if (ipart>0 && ipart<=PART_MAX) {
1102 if (part_nowrite(name) & PTW_NTFS) {
1103 vm[found].flag |= NTCAUTION;
1104 vm[found].nt[ipart-1] = NTCAUTION;
1106 if (verbose>=4) printf("NT partition: %s %d %s\n",
1107 vm[found].name, ipart, name);
1111 } /* if (mask && (device & P_MASK(device)) ) */
1113 } /* while (!feof()) */
1115 if (line) free(line);
1122 for (i=0; i<ndevs; i++)
1123 printf(" %04X %08X %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1126 if (verbose>=2) printf("pf_hard_disk_scan: ndevs=%d\n", ndevs);
1128 /* now sort the volumes into canonical order */
1132 for (j=ndevs-1; j>0; j--)
1134 if (vm[i].sort > vm[i+1].sort) {
1135 struct VolumeMgmt temp;
1141 /* now automatically treat MDP-RAID devices as inaccessible */
1142 for (k=0; k<ndevs; k++) {
1144 if (MAJOR(vm[k].device) == MAJOR_MDP ||
1145 MAJOR(vm[k].device) == MAJOR_EMD ) {
1147 if (verbose>=2) printf("MDP-RAID detected, k=%d\n", k);
1148 if (cfg_get_flag(cf_options, "noraid") ) {
1150 warn("RAID controller present, with \"noraid\" keyword used.\n"
1151 " Underlying drives individually must be marked INACCESSIBLE." );
1153 for (j=0; j<ndevs; j++) {
1154 if (j==k) break; /* skip ourselves */
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
1161 j=ndevs; /* terminate loop */
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;
1171 if (verbose >= 4) printf("Allocated DT entry for device %04X ptr=%08lx\n", vm[j].device, (long)walk);
1175 if (vm[j].dt->heads != 0) {
1176 vm[j].dt->heads = 0;
1177 warn("(MDP-RAID) underlying device flagged INACCESSIBLE: %s",
1181 warn("bypassing VolumeID check of underlying MDP-RAID drive:\n"
1183 vm[j].device, vm[j].vol_id.kernel, vm[j].name);
1184 for (i=j; i<ndevs; i++) vm[i] = vm[i+1];
1192 if (MAJOR(vm[k].device) == MAJOR_EMD ||
1193 MAJOR(vm[k].device) == MAJOR_MDP ) {
1195 warn("MDP-RAID controller present; underlying drives individually\n"
1196 " must be marked INACCESSIBLE." );
1202 if ((mdp_fd=dev_open(&dev, vm[k].device, O_NOACCESS) ) < 0)
1203 die("Unable to open %s",vm[k].name);
1211 if ( MAJOR(vm[k].device) == MAJOR_DM ) {
1212 if (verbose>=2) printf("ATA-RAID detected, k=%d\n", k);
1214 warn("ATA-RAID controller present;\n"
1215 " Underlying drives individually must be marked INACCESSIBLE." );
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");
1227 /* now go thru and resolve any invalid VolumeIDs */
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;
1236 vm[i].vol_id.kernel = volid_get_set(dev, new_serial(dev), ID_SET);
1237 vm[i].flag &= ~INVALID;
1241 printf("Resolve duplicate VolumeIDs\n");
1243 /* now check for duplicates */
1245 while (duplicate) { /* loop until there are none */
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."
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);
1264 else if (vm[i].flag & NTCAUTION) k = j;
1265 else if (vm[j].flag & NTCAUTION) k = i;
1269 vm[k].vol_id.kernel = volid_get_set(dev, new_serial(dev), ID_SET);
1274 } /* while (duplicate) */
1279 for (i=0; i<ndevs; i++)
1280 printf(" %04X %08X %s\n", vm[i].device, vm[i].vol_id.kernel, vm[i].name);
1285 if (verbose>=2) printf("device codes (user assigned pf) = %lX\n", codes);
1287 /* mark those BIOS codes that are already used in the disk=/bios= table */
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)) {
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;
1304 if (verbose>=3) printf("J=%d K=%d\n", j, k);
1307 die("Devices %04X and %04X are assigned to BIOS 0x%02X",
1308 vm[k].device, walk->device, bios+0x80);
1311 codes |= 1L << bios;
1315 if (verbose>=2) printf("device codes (user assigned) = %lX\n", codes);
1317 for (i=0; i<ndevs; i++) {
1318 bios = vm[i].bios.probe;
1320 if (vm[i].bios.actual < 0x80 && !(codes & (1L<<(bios&0x7F)))) {
1321 vm[i].bios.actual = bios;
1323 codes |= 1L << bios;
1328 if (verbose>=2) printf("device codes (BIOS assigned) = %lX\n", codes);
1330 for (bios=i=0; i<ndevs; i++) {
1334 if (vm[i].bios.actual < 0x80) {
1335 while ( codes & (1L<<bios) ) bios++;
1336 if (bios < MAX_BIOS_DEVICES) {
1338 vm[i].bios.actual = 0x80+bios;
1339 if (verbose>=3) printf("Filling in '%s' = 0x%02X\n", vm[i].name, bios+0x80);
1341 else vm[i].bios.actual = -1;
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;
1350 if (verbose >= 4) printf("Allocated DT entry for device %04X ptr=%08lx\n", vm[i].device, (long)walk);
1353 j = vm[i].dt->bios = vm[i].bios.actual;
1356 if (j < MAX_BIOS_DEVICES) {
1357 serial_no[j] = vm[i].vol_id.kernel;
1358 device_code[j] = vm[i].device;
1361 printf("Generated: %02X %04X %08X\n", j+0x80, device_code[j], (int)serial_no[j]);
1366 vm[i].dt->heads = 0; /* mark inaccessible */
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);
1380 if (verbose>=2) printf("device codes (canonical) = %lX\n", codes);
1382 for (bios=8*sizeof(codes)-1; !(codes&(1L<<bios)) && bios>=0; ) bios--;
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);