bsect.c

LINUX lilo-22.7 源代码。

	*(unsigned short *) fallback_buf = DC_MAGIC;
	strcpy(fallback_buf+2,fback);
	fallback[fallbacks++] = stralloc(fback);
#endif
    }
#if 0
#if 1
    *(unsigned int *) descr->rd_size = 0; /* no RAM disk */
#else
    descr->rd_size = 0; /* no RAM disk */
#endif
    descr->start_page = 0; /* load low */
#endif
    map_begin_section();
    map_add_sector(fallback_buf);
    map_add_sector(options);
}


static void bsect_done(char *name,IMAGE_DESCR *descr)
{
    char *alias;
    int this_image,this;

    if (!*name) die("Invalid image name.");
    alias = cfg_get_strg(cf_all,"alias");
    this = alias ? get_image(NULL,alias,descr) : -1;
    this_image = get_image(name,cfg_get_strg(cf_all,"label"),descr);
    if ((descr->flags & FLAG_SINGLE) &&
      strlen(descrs.d.descr[this_image].name) > 1 &&
      (!alias || strlen(alias) > 1))
	die("SINGLE-KEYSTROKE requires the label or the alias to be only "
	  "a single character");
    if (verbose >= 0) {
	printf("Added %s",descrs.d.descr[this_image].name);
	if (alias) printf(" (alias %s)",alias);
#ifdef LCF_VIRTUAL
	if (descrs.d.descr[this_image].flags & FLAG_VMDEFAULT ||
		(this>=0 && (descrs.d.descr[this].flags & FLAG_VMDEFAULT)) )
	    printf(" @");
#endif
	if (descrs.d.descr[this_image].flags & FLAG_TOOBIG ||
		(this>=0 && (descrs.d.descr[this].flags & FLAG_TOOBIG)) )
	    printf(" ?");
	if (this_image && this) putchar('\n');
	else printf(" *\n");
    }
    if (verbose >= 3) {
	printf("%4s<dev=0x%02x,hd=%d,cyl=%d,sct=%d>\n","",
	  descr->start.device,
	  descr->start.head,
	  descr->start.track,
	  descr->start.sector);
	if (*options) printf("%4s\"%s\"\n","",options);
    }
    if (verbose >= 1) putchar('\n');   /* makes for nicer spacing */
}


int bsect_number(void)
{
 /* -1 means default= did not exist */
    return image_base ? -1 : image;
}


static void unbootable(void)
{
    fflush(stdout);
    fprintf(errstd,"\nWARNING: The system is unbootable !\n");
    fprintf(errstd,"%9sRun LILO again to correct this.","");
}


void check_fallback(void)
{
    char *start,*end;
    int i,image;

    for (i = 0; i < fallbacks; i++) {
	for (start = fallback[i]; *start && *start == ' '; start++);
	if (*start) {
	    for (end = start; *end && *end != ' '; end++);
	    if (*end) *end = 0;
	    for (image = 0; image < MAX_IMAGES; image++)
#ifdef LCF_IGNORECASE
		if (!strcasecmp(descrs.d.descr[image].name,start)) break;
#else
		if (!strcmp(descrs.d.descr[image].name,start)) break;
#endif
	    if (image == MAX_IMAGES) die("No image \"%s\" is defined",start);
	}
    }
}

void check_unattended(void)
{
    if ( (descrs.d.descr[0].flags & (FLAG_PASSWORD + FLAG_RESTR) )
							== FLAG_PASSWORD
		&&  cfg_get_flag(cf_options,"unattended") )
	die("Mandatory PASSWORD on default=\"%s\" defeats UNATTENDED",
		descrs.d.descr[0].name);
}


void bsect_update(char *backup_file, int force_backup, int pass)
{
    BOOT_SECTOR bsect_wr;
    int temp;
static int timestamp = 0;

    if (pass>=0) {
	temp = make_backup(backup_file, force_backup, &bsect_orig,
    						boot_dev_nr, "boot sector");
	if (temp && !timestamp) bsect.par_1.timestamp = timestamp = temp;
    }

#ifndef LCF_UNIFY
# error "Bios Translation algorithms require '-DUNIFY' in Makefile"
#endif
    if (pass<1) {	/* BIOS_TT logic */
	MENUTABLE *menu = &menuparams;
	map_descrs(&descrs, menu->mt_descr, &menuparams.dflcmd);
	menuparams.raid_dev_mask = raid_mask(menuparams.raid_offset);
	memcpy(menuparams.serial_no, serial_no, sizeof(serial_no));
	memcpy(table+256, &menuparams, sizeof(menuparams));
	((int*)table)[SECTOR_SIZE/sizeof(int)-2] = crc32(table, SECTOR_SIZE-2*sizeof(int), CRC_POLY1);
	map_begin_section();
	map_add_sector(table);
#ifdef LCF_FIRST6
	/* still use 5 byte address */
	(void) map_write(&param2.keytab,1,0,0);
#else
	(void) map_write(&param2.keytab,1,0);
#endif
	map_close(&param2, here2);
    }	/* if (pass<1) ...	*/

if (pass>=0) {
    if (lseek(fd,0,SEEK_SET) < 0)
	die("lseek %s: %s",
		boot_devnam ? boot_devnam : dev.name,
		strerror(errno));

#if 1
    if (ireloc &&
    	  bsect.par_1.cli == 0xFA
    	 						 ) {
/* perform the relocation of the boot sector */
	int len = bsect.par_1.code_length;
	int space = BOOT_SIG_OFFSET - len;
	
	if (len==0) die ("First stage loader is not relocatable.");
	
	space &= 0xFFF0;	/* roll back to paragraph boundary */
	bsect_wr = bsect_orig;
	memcpy(&bsect_wr.sector[space], &bsect, len);
	if (space <= 0x80) {
	    bsect_wr.sector[0] = 0xEB;		/* jmp short */
	    bsect_wr.sector[1] = space - 2;
	    bsect_wr.sector[2] = 0x90;		/* nop */
	} else {
	    bsect_wr.sector[0] = 0xE9;		/* jmp near */
	    *(short*)&bsect_wr.sector[1] = space - 3;
	}
	if (bsect_wr.sector[space+1] == 0xEB)	{  /* jmp short */
	    len = space>>4;
	    space += (signed)bsect_wr.sector[space+2] + 3;
	    if (bsect_wr.sector[space] == 0xB8)	/* mov ax,#07C0 */
		*(short*)&bsect_wr.sector[space+1] += len;
	}
/***	bsect = bsect_orig;  ***/
	if (verbose >= 1) printf("Boot sector relocation performed\n");
    }
    else bsect_wr = bsect;
#endif    	

 /* failsafe check */
#if 1
    if (verbose >= 3) {
	printf("Failsafe check:  boot_dev_nr = 0x%04x 0x%04x\n", boot_dev_nr, has_partitions(boot_dev_nr));
	/*** if (do_md_install) ***/ {
	    printf("map==boot = %d    map s/n = %08X\n",
		!!(bsect_wr.par_1.prompt & FLAG_MAP_ON_BOOT),
		bsect_wr.par_1.map_serial_no
	    );
	}
    }
#endif
    if (
      has_partitions(boot_dev_nr) &&
      (P_MASK(boot_dev_nr)&boot_dev_nr)==0 &&
      memcmp(bsect.sector+MAX_BOOT_SIZE, bsect_wr.sector+MAX_BOOT_SIZE, 64+8)
      )
    	die("LILO internal error:  Would overwrite Partition Table");
 /* failsafe check */
    	
    if (!test && write(fd, (char *)&bsect_wr, SECTOR_SIZE) != SECTOR_SIZE)
	die("write %s: %s",boot_devnam ? boot_devnam : dev.name,
	  strerror(errno));

} /* if (pass>=0) ... */

    if (use_dev_close) dev_close(&dev);
    else if (close(fd) < 0) {
	    unbootable();
	    die("close %s: %s",boot_devnam,strerror(errno));
	}

#if 0
    if (pass==0) {
#else
    if (pass<1) {
#endif
	pw_file_update(passw);
	temp_unregister(temp_map);
	if (rename(temp_map,map_name) < 0) {
	    unbootable();
	    die("rename %s %s: %s",temp_map,map_name,strerror(errno));
	}
    }
/*  (void) sync();   Now handled in lilo.c (atexit(sync)) */
	if (verbose>=6) printf("End  bsect_update\n");
	fflush(stdout);
}


void bsect_cancel(void)
{
#if 0
    map_descrs(&descrs, bsect.par_1.descr, &bsect.par_1.dflcmd);
#endif
    map_close(NULL,0);
    if (!use_dev_close) (void) close(fd);
    else dev_close(&dev);
    temp_unregister(temp_map);
    if (verbose<9) (void) remove(temp_map);
}


static int present(char *var)
{
    char *path;

    if (!(path = cfg_get_strg(cf_top,var))) die("No variable \"%s\"",var);
    if (!access(path,F_OK)) return 1;
    if (!cfg_get_flag(cf_all,"optional") && !cfg_get_flag(cf_options,
      "optional")) return 1;
    if (verbose >= 0) printf("Skipping %s\n",path);
    return 0;
}


static int initrd_present(void)
{
    char *path;

    path = cfg_get_strg(cf_kernel, "initrd");
    if (!path) path = cfg_get_strg(cf_options, "initrd");
    if (!path) return 1;
    if (!access(path,F_OK)) return 1;
    if (!cfg_get_flag(cf_all,"optional") && !cfg_get_flag(cf_options,
      "optional")) return 1;
    if (verbose >= 0) printf("Skipping %s\n", cfg_get_strg(cf_top, "image"));
    return 0;
}


void do_image(void)
{
    IMAGE_DESCR descr;
    char *name;

/*    memset(&descr, 0, sizeof(descr));  	Done in "bsect_common" */
    cfg_init(cf_image);
    (void) cfg_parse(cf_image);
    if (present("image") && initrd_present()) {
	bsect_common(&descr, 1);
	descr.flags |= FLAG_KERNEL;
	name = cfg_get_strg(cf_top,"image");
	if (!cfg_get_strg(cf_image,"range")) boot_image(name,&descr);
	else boot_device(name,cfg_get_strg(cf_image,"range"),&descr);
	bsect_done(name,&descr);
    }
    cfg_init(cf_top);
}


void do_other(void)
{
    IMAGE_DESCR descr;
    char *name, *loader;

/*    memset(&descr, 0, sizeof(descr));  	Done in "bsect_common" */
    cfg_init(cf_other);
    cfg_init(cf_kernel); /* clear kernel parameters */
    curr_drv_map = curr_prt_map = 0;
    (void) cfg_parse(cf_other);
    if (present("other")) {
	bsect_common(&descr, 0);
	name = cfg_get_strg(cf_top,"other");
	loader = cfg_get_strg(cf_other,"loader");
	if (!loader) loader = cfg_get_strg(cf_options,"loader");
	boot_other(loader,name,cfg_get_strg(cf_other,"table"),&descr);
	bsect_done(name,&descr);
    }
    cfg_init(cf_top);
}


void bsect_uninstall(char *boot_dev,char *backup_file,int validate)
{
    struct stat st;
    char temp_name[PATH_MAX+1];
    int bck_file;

    open_bsect(boot_dev);
    if (*(unsigned short *) &bsect.sector[BOOT_SIG_OFFSET] != BOOT_SIGNATURE)
	die("Boot sector of %s does not have a boot signature",boot_dev ?
	  boot_dev : dev.name);
    if (!strncmp(bsect.par_1.signature-4,"LILO",4))
	die("Boot sector of %s has a pre-21 LILO signature",boot_dev ?
	  boot_dev : dev.name);
    if (strncmp(bsect.par_1.signature,"LILO",4))
	die("Boot sector of %s doesn't have a LILO signature",boot_dev ?
	  boot_dev : dev.name);
    if (!backup_file) {
	sprintf(temp_name,BACKUP_DIR "/boot.%04X",boot_dev_nr);
	backup_file = temp_name;
    }
    if ((bck_file = open(backup_file,O_RDONLY)) < 0)
	die("open %s: %s",backup_file,strerror(errno));
    if (fstat(bck_file,&st) < 0)
	die("fstat %s: %s",backup_file,strerror(errno));
    if (validate && st.st_mtime != bsect.par_1.timestamp)
	die("Timestamp in boot sector of %s differs from date of %s\n"
	  "Try using the -U option if you know what you're doing.",boot_dev ?
	  boot_dev : dev.name,backup_file);
    if (verbose > 0) printf("Reading old boot sector.\n");
    if (read(bck_file,(char *) &bsect,PART_TABLE_OFFSET) != PART_TABLE_OFFSET)
	die("read %s: %s",backup_file,strerror(errno));
    if (lseek(fd,0,SEEK_SET) < 0)
	die("lseek %s: %s",boot_dev ? boot_dev : dev.name,strerror(errno));
    if (verbose > 0) printf("Restoring old boot sector.\n");
    if (write(fd,(char *) &bsect,PART_TABLE_OFFSET) != PART_TABLE_OFFSET)
	die("write %s: %s",boot_dev ? boot_dev : dev.name,strerror(errno));
    if (use_dev_close) dev_close(&dev);
    else if (close(fd) < 0) {
	    unbootable();
	    die("close %s: %s",boot_devnam,strerror(errno));
	}
    exit(0);
}


void bsect_raid_update(char *boot_dev, unsigned int raid_offset, 
	char *backup_file, int force_backup, int pass, int mask)
{
    BOOT_SECTOR bsect_save;
    int bios;
    int prompt = bsect.par_1.prompt;

    if (pass<0) bsect_update(backup_file, force_backup, pass);

    if (pass != 0) {    
	bsect_save = bsect;			/* save the generated boot sector */
	open_bsect(boot_dev);
	memcpy(&bsect, &bsect_save, MAX_BOOT_SIZE);	/* update the subject boot sector */
	bsect.par_1.raid_offset = raid_offset;	/* put in the new partition offset */
	bsect.par_1.prompt &= mask;		/* clear all RAID flags */
	bsect.par_1.prompt |= raid_flags;	/* update the raid flags */

	bios = (raid_flags&FLAG_RAID_DEFEAT) ? bios_map : bios_boot;
	if (!cfg_get_flag(cf_options, "static-bios-codes")) {
	    if (verbose>=2) printf("Using s/n from device 0x%02X\n", bios);
	    bsect.par_1.map_serial_no = serial_no[bios - 0x80];
	}

#ifdef LCF_FIRST6
/* lines added 22.5.7 */
	((SECTOR_ADDR6*)&bsect.par_1.secondary)->device = bios;
#else
/* lines added 22.5.6 */
	bsect.par_1.secondary.device &= ~DEV_MASK;
	bsect.par_1.secondary.device |= bios;
#endif
/* ************************************ */

	*(unsigned short *) &bsect.sector[BOOT_SIG_OFFSET] = BOOT_SIGNATURE;
    }
    
    if (pass<0) pass = -pass;
    
    bsect_update(backup_file, force_backup, pass);

    bsect.par_1.prompt = prompt;	/* restore the flag byte */
}