Author: odabrunz Date: Tue Jul 10 22:37:55 2007 New Revision: 39303 URL: http://svn.opensuse.org/viewcvs/yast?rev=39303&view=rev Log: - GRUB only: integrated the new boot_*, generic_mbr and activate keys (found in the "globals" map) from the new widget/perl-Bootloader interface into the internal workings of the grub code - for grub, this obsoletes the global variables loader_device, selected_location (aka loader_location), repl_mbr and activate - fixes loosing the information of multiple selected bootloader installation devices (#245680) - fixes faulty detection of user-changes to the "/boot" and "/" devices from yast2-storage (#247852) - decided that boot_mbr_md key is unneeded, because the decision to write to the MBRs of all underlying devices of a soft-RAID is automatic (kept commented-out sample code for boot_mbr_md) - decided that boot_extended is unneeded, because the decision to write the bootloader to the extended partition instead of to an un-activatable "/boot" or "/" partition is automatic (kept commented-out sample code for boot_extended) - removed wrapper code for variable translation from BootGRUB::Propose() - made private copies of functions in grub/misc.ycp and changed the code to use the new interface variables only (this is also wanted for better code separation between bootloaders, to reduce amount of special-case handling (to be worked on)): * from routines/misc.ycp: grub_getPartitionToActivate () grub_getPartitionsToActivate () grub_getMbrsToRewrite () grub_getFileChangeDate () grub_saveMBR () grub_updateMBR () grub_DetectDisks () * from routines/lilolike.ycp: grub_ProposeDeviceMap () ( ^^ really needed? no changes here, it just "belongs" to grub...) grub_ConfigureLocation() grub_DetectDisks () grub_DisksChanged () grub_LocationProposal () - added helper functions: grub/misc.ycp: SetBootloaderDevice() routines/misc.ycp: GetBootloaderDevices() - added note to to-be-phased-out functions: routines/misc.ycp: GetBootloaderDevice() - made some functions globally accessible: routines/popup.ycp: askLocationResetPopup () routines/misc.ycp: myToInteger () routines/lilolike.ycp: FindMBRDisk () - fixed bug with the detection of MD-RAID devices (both in grub_getPartitionToActivate and getPartitionToActivate): BIOS ID was assumed to be less than 128, but it starts at 128 - commented out some obsolete and broken code that would activate the "/boot" device on installation of the bootloader to MBR; the code was cancelled out by program logic ("activate" flag) though; this also simplified the interface to getPartitionToActivate () - added conditionals to Bootloader.ycp and BootCommon.ycp: do not handle obsolete variables for grub - commented out probably obsolete code in BootGRUB::Read() to determine old_style loader_device from read devices (including old-style "mbr_md") - added several FIXME:s - changed a fixed FIXME to FIXED - when reading settings from the system: convert custom boot device names in globals to the kernel device names (#248162) - corrected whitespace in grub/helps.ycp and ppc/helps.ycp Modified: trunk/bootloader/src/grub/helps.ycp trunk/bootloader/src/grub/misc.ycp trunk/bootloader/src/modules/BootCommon.ycp trunk/bootloader/src/modules/BootGRUB.ycp trunk/bootloader/src/modules/BootPOWERLILO.ycp trunk/bootloader/src/modules/Bootloader.ycp trunk/bootloader/src/ppc/helps.ycp trunk/bootloader/src/routines/autoinstall.ycp trunk/bootloader/src/routines/lilolike.ycp trunk/bootloader/src/routines/misc.ycp trunk/bootloader/src/routines/popups.ycp Modified: trunk/bootloader/src/grub/helps.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/grub/helps.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/grub/helps.ycp (original) +++ trunk/bootloader/src/grub/helps.ycp Tue Jul 10 22:37:55 2007 @@ -128,44 +128,44 @@ global map grub_descriptions = $[ "boot" : _("Boot Loader Locations"), "activate" : _("Set active Flag in Partition Table for Boot Partition"), - "timeout" : _("Timeout in Seconds"), - "default" : _("Default Boot Section"), - "generic_mbr" : _("Write generic Boot Code to MBR"), - "boot_custom" : _("Custom Boot Partition"), - "boot_mbr" : _("Boot from Master Boot Record"), - "boot_root" : _("Boot from Root Partition"), - "boot_boot" : _("Boot from Boot Partition"), - "serial" : _("Serial Connection Parameters"), - "terminal" : _("Terminal Definition"), - "fallback" : _("Fallback Sections if default Fails"), - "hiddenmenu" : _("Hide Menu on Boot"), - "gfxmenu" : _("Graphical Menu File"), - "password" : _("Password for the Menu Interface"), - "debug" : _("Debugging Flag"), - "type_image" : _("Image Section"), - "image_image" : _("Kernel Image"), - "image_root" : _("Root Device"), - "image_vgamode" : _("Vga Mode"), - "image_append" : _("Optional Kernel Command Line Parameter"), - "image_initrd" : _("Initial RAM Disk"), - "image_noverifyroot" : _("Do not verify Filesystem before Booting"), + "timeout" : _("Timeout in Seconds"), + "default" : _("Default Boot Section"), + "generic_mbr" : _("Write generic Boot Code to MBR"), + "boot_custom" : _("Custom Boot Partition"), + "boot_mbr" : _("Boot from Master Boot Record"), + "boot_root" : _("Boot from Root Partition"), + "boot_boot" : _("Boot from Boot Partition"), + "serial" : _("Serial Connection Parameters"), + "terminal" : _("Terminal Definition"), + "fallback" : _("Fallback Sections if default Fails"), + "hiddenmenu" : _("Hide Menu on Boot"), + "gfxmenu" : _("Graphical Menu File"), + "password" : _("Password for the Menu Interface"), + "debug" : _("Debugging Flag"), + "type_image" : _("Image Section"), + "image_image" : _("Kernel Image"), + "image_root" : _("Root Device"), + "image_vgamode" : _("Vga Mode"), + "image_append" : _("Optional Kernel Command Line Parameter"), + "image_initrd" : _("Initial RAM Disk"), + "image_noverifyroot" : _("Do not verify Filesystem before Booting"), "type_other" : _("Chainloader Section"), - "other_lock" : _("Use Password Protection"), - "other_chainloader" : _("Other System"), + "other_lock" : _("Use Password Protection"), + "other_chainloader" : _("Other System"), "other_noverifyroot" : _("Do not verify Filesystem before Booting"), - "other_makeactive" : _("Activate this Partition when selected for Boot"), - "other_blockoffset" : _("Block Offset for Chainloading"), - "type_xen" : _("Xen Section"), - "xen_xen" : _("Hypervisor"), - "xen_xen_append" : _("Additional Xen Hypervisor Parameters"), - "xen_image" : _("Kernel Image"), - "xen_root" : _("Root Device"), + "other_makeactive" : _("Activate this Partition when selected for Boot"), + "other_blockoffset" : _("Block Offset for Chainloading"), + "type_xen" : _("Xen Section"), + "xen_xen" : _("Hypervisor"), + "xen_xen_append" : _("Additional Xen Hypervisor Parameters"), + "xen_image" : _("Kernel Image"), + "xen_root" : _("Root Device"), "xen_vgamode" : _("Vga Mode"), - "xen_append" : _("Optional Kernel Command Line Parameter"), - "xen_initrd" : _("Initial RAM Disk"), - "type_menu" : _("Menu Section"), - "menu_root" : _("Partition of Menu File"), - "menu_configfile" : _("Menu Description File"), + "xen_append" : _("Optional Kernel Command Line Parameter"), + "xen_initrd" : _("Initial RAM Disk"), + "type_menu" : _("Menu Section"), + "menu_root" : _("Partition of Menu File"), + "menu_configfile" : _("Menu Description File"), ]; Modified: trunk/bootloader/src/grub/misc.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/grub/misc.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/grub/misc.ycp (original) +++ trunk/bootloader/src/grub/misc.ycp Tue Jul 10 22:37:55 2007 @@ -21,91 +21,929 @@ import "StorageDevices"; import "Mode"; import "BootCommon"; + import "PackageSystem"; + + +// -------------------------------------------------------------- +// -------------------------------------------------------------- +// updateMBR and related stuff (taken from routines/misc.ycp) /** - * Propose whether allow or not embedding of 1.5 stage - * @return boolean true to allow - */ - define boolean allowEmbed15 () { - // allow only for /boot or /root device selected - if (! (BootCommon::loader_device == BootCommon::BootPartitionDevice - || BootCommon::loader_device == BootCommon::RootPartitionDevice - || BootCommon::loader_device == BootCommon::mbrDisk - )) - { - return false; - } - // check filesystem on /boot for Reiserfs and JFS - map mp = Storage::GetMountPoints (); - list bp_info - = mp["/boot"]:mp["/"]:[]; - list<map> partitions - = Storage::GetTargetMap ()[bp_info[2]:"", "partitions"]:[]; - boolean ret = false; - foreach (map p, partitions, { - if (p["device"]:"" == BootCommon::BootPartitionDevice) - { - symbol fs = (symbol)p["used_fs"]:nil; - if (fs == `reiser || fs == `jfs) - ret = true; - } - }); - return ret; - } - - /** - * Encrypt the password before storing it in variables - * @param passwd string unencrypted password - * @return string password in the form to write to GRUB's menu.lst + * Given a device name to which we install the bootloader (loader_device), + * get the name of the partition which should be activated. + * Also return the device file name of the disk device that corresponds to + * loader_device (i.e. where the corresponding MBR can be found). + * @param loader_device string the device to install bootloader to + * @return a map $[ "dev" : string, "mbr": string, "num": any] + * containing device (eg. "/dev/hda4"), disk (eg. "/dev/hda") and + * partition number (eg. 4) + */ +// * @param boot_partition string the partition holding /boot subtree +// map getPartitionToActivate (string boot_partition, +// string loader_device) + map grub_getPartitionToActivate (string loader_device) + { + map p_dev = Storage::GetDiskPartition (loader_device); + integer num = BootCommon::myToInteger( p_dev["nr"]:nil ); + string mbr_dev = p_dev["disk"]:""; + + // If loader_device is /dev/md* (which means bootloader is installed to + // /dev/md*), return the info map for the first device in BIOS ID order + // that underlies the soft-RAID and that has a BIOS ID (devices without + // BIOS ID are excluded). + // If no device is found in this way, return the info map for the + // soft-RAID device ("/dev/md", "/dev/md[0-9]*"). + // FIXME: use ::storage to detect md devices, not by name! + // FIXME: return info for ALL underlying soft-RAID devices here, so + // that all MBRs can be backed-up and all partitions that need to be + // activated can be activated. This requires a map> return + // value, and code on the caller side that evaluates this. + if (substring (loader_device, 0, 7) == "/dev/md") + { + map md = BootCommon::Md2Partitions (loader_device); + integer min = 256; // max. is 255; 256 means "no bios_id found" + string device = ""; + foreach (string d, integer id, md, { + if (id < min) + { + min = id; + device = d; + } + }); + if (device != "") + { + map p_dev = Storage::GetDiskPartition (device); + num = BootCommon::myToInteger( p_dev["nr"]:nil ); + mbr_dev = p_dev["disk"]:""; + } + } + // If loader_device is a disk device ("/dev/sda"), that means that we + // install the bootloader to the MBR. In this case, activate /boot + // partition. + // (partial fix of #20637) + // FIXME: necessity and purpose are unclear: if we install the + // bootloader to the MBR, then why do we need to activate the /boot + // partition? Stage1 of a GRUB has the first block of the stage2 + // hard-coded inside. + // This code was added because a /boot partition on a /dev/cciss device + // was not activated in bug #20637. Anyway, it probably never worked, + // since the bootloader was not installed to the MBR in that bug (and + // thus this code is not triggered). + // The real problem may have been that Storage::GetDiskPartition() did + // not know how to parse /dev/cciss/c0d0p1, so that the default case at + // the beginning of this function did not set up correct values. These + // days, Storage::GetDiskPartition() looks OK with /dev/cciss. + // Deactivated this code, so that "/boot" does not get activated + // unecessarily when GRUB stage1 is installed to the MBR anyway (this + // would unecessarily have broken drive C: detection on older MS + // operating systems). +// else if (num == 0) +// { +// p_dev = Storage::GetDiskPartition (boot_partition); +// num = BootCommon::myToInteger( p_dev["nr"]:nil ); +// mbr_dev = p_dev["disk"]:""; +// +// if (size (BootCommon::Md2Partitions (boot_partition)) > 1) +// { +// foreach (string k, integer v, BootCommon::Md2Partitions (boot_partition),{ +// if (search (k, loader_device) == 0) +// { +// p_dev = Storage::GetDiskPartition (k); +// num = BootCommon::myToInteger( p_dev["nr"]:nil ); +// mbr_dev = p_dev["disk"]:""; +// } +// }); +// } +// } + if (num != 0) + { + if (num > 4) + { + y2milestone ("Bootloader partition type is logical"); + map tm = Storage::GetTargetMap (); + list<map> partitions = tm[mbr_dev, "partitions"]:[]; + foreach (map p, partitions, ``{ + if (p["type"]:nil == `extended) + { + num = p["nr"]:num; + y2milestone ("Using extended partition %1 instead", + num); + } + }); + } + } + map ret = $[ + "num" : num, + "mbr" : mbr_dev, + "dev" : Storage::GetDeviceName (mbr_dev, num), + ]; + return ret; + } + + /** + * Get a list of partitions to activate if user wants to activate + * boot partition + * @return a list of partitions to activate */ - global define string updatePasswdBeforeSave (string passwd) ``{ - passwd = sformat ("--md5 %1", cryptmd5 (passwd)); - return passwd; + list > grub_getPartitionsToActivate () { + map md = $[]; + list underlying_devs = []; + list<string> devs = []; + + // get a list of all bootloader devices or their underlying soft-RAID + // devices, if necessary + underlying_devs = maplist (string dev, BootCommon::GetBootloaderDevices(), { + md = BootCommon::Md2Partitions(dev); + if ( size(md) > 0 ) { + devs = maplist (string k, integer v, md, ``(k)); + return devs; + } + return [dev]; + }); + list<string> bootloader_base_devices = flatten(underlying_devs); + + if (size (bootloader_base_devices) == 0) + { + bootloader_base_devices = BootCommon::GetBootloaderDevices(); + } + list > ret = maplist (string partition, bootloader_base_devices, { + return grub_getPartitionToActivate (partition); + }); + return toset (ret); } /** - * translate filename path (eg. (hd0,0)/kernel) to list of device - * and relative path - * @param devpth string fileststem path (eg. (hd0,0)/vmlinuz) - * @return a list containing device and relative path, - * eg. ["(hd0,0)", "/vmlinuz"] + * Get the list of MBR disks that should be rewritten by generic code + * if user wants to do so + * @return a list of device names to be rewritten */ - // FIXME: this should never happen but handled through perl-Bootloader completely - global define list<string> splitDevPath (string devpth) ``{ - y2milestone("FIXME: called splitDevPath(%1) which points to a bug in perl-Bootloader", - devpth); - integer brake = nil; - if (devpth != nil && issubstring (devpth, ")")) - brake = findfirstof (devpth, ")") + 1; - list<string> ret = []; - if (brake != nil) + list<string> grub_getMbrsToRewrite () { + list<string> ret = [BootCommon::mbrDisk]; + map md = $[]; + list underlying_devs = []; + list<string> devs = []; + + // get a list of all bootloader devices or their underlying soft-RAID + // devices, if necessary + underlying_devs = maplist (string dev, BootCommon::GetBootloaderDevices(), { + md = BootCommon::Md2Partitions(dev); + if ( size(md) > 0 ) { + devs = maplist (string k, integer v, md, ``(k)); + return devs; + } + return [dev]; + }); + list<string> bootloader_base_devices = flatten(underlying_devs); + + // find the MBRs on the same disks as the devices underlying the boot + // devices; if for any of the "underlying" or "base" devices no device + // for acessing the MBR can be determined, include mbrDisk in the list + list<string> mbrs = maplist (string dev, bootloader_base_devices, { + dev = (grub_getPartitionToActivate (dev))["mbr"]:BootCommon::mbrDisk; + return dev; + }); + // FIXME: the exact semantics of this check is unclear; but it seems OK + // to keep this as a sanity check and a check for an empty list; + // mbrDisk _should_ be included in mbrs; the exact cases for this need + // to be found and documented though + if (contains (mbrs, BootCommon::mbrDisk)) { - ret[0] = substring (devpth, 0, brake); - ret[1] = substring (devpth, brake); + ret = (list<string>)merge (ret, mbrs); } - else + return toset (ret); + } + + /** + * Get last change time of file + * @param filename string name of file + * @return string last change date as YYYY-MM-DD-HH-MM-SS + */ + string grub_getFileChangeDate (string filename) { + map stat = (map) SCR::Read (.target.stat, filename); + integer ctime = stat["ctime"]:0; + string command = sformat ( + "date --date='1970-01-01 00:00:00 %1 seconds' +\"%%Y-%%m-%%d-%%H-%%M-%%S\"", + ctime); + map out = (map) SCR::Execute (.target.bash_output, command); + string c_time = out["stdout"]:""; + y2debug ("File %1: last change %2", filename, c_time); + return c_time; + } + + /** + * Save current MBR to /boot/backup_mbr + * Also save to /var/lib/YaST2/backup_boot_sectors/%device, if some + * existing, rename it + * @param device string name of device + */ + void grub_saveMBR (string device) { + string device_file = mergestring (splitstring (device, "/"), "_"); + string device_file_path = "/var/lib/YaST2/backup_boot_sectors/" + + device_file; + SCR::Execute (.target.bash, + "test -d /var/lib/YaST2/backup_boot_sectors || mkdir /var/lib/YaST2/backup_boot_sectors"); + if (SCR::Read (.target.size, device_file_path) > 0) { - ret[0] = nil; - ret[1] = devpth; + list<string> contents = (list<string>) SCR::Read (.target.dir, "/var/lib/YaST2/backup_boot_sectors"); + contents = filter (string c, contents, ``(regexpmatch (c, sformat ( + "%1-.*-.*-.*-.*-.*-.*", device_file)))); + contents = sort (contents); + integer index = 0; + integer siz = size (contents); + while (index + 10 < siz) + { + SCR::Execute (.target.remove, + sformat ("/var/lib/YaST2/backup_boot_sectors/%1", contents[index]:"")); + index = index + 1; + } + string change_date = grub_getFileChangeDate (device_file_path); + SCR::Execute (.target.bash, sformat ( + "/bin/mv %1 %1-%2", + device_file_path, change_date)); + } + SCR::Execute (.target.bash, sformat ( + "/bin/dd if=%1 of=%2 bs=512 count=1 2>&1", + device, device_file_path)); + if (device == BootCommon::mbrDisk) + { + SCR::Execute (.target.bash, sformat ( + "/bin/dd if=%1 of=%2 bs=512 count=1 2>&1", + device, "/boot/backup_mbr")); + } - return ret; } /** - * translate list of device and relative path - * to filename path (eg. (hd0,0)/kernel) - * @param devpth list of two strings, first for device name, second for - * relative path (eg. ["(hd0,0)", "/vmlinuz"]) - * @return string fileststem path (eg. (hd0,0)/vmlinuz) + * Update contents of MBR (active partition and booting code) + * FIXME move tis function to lilolike.ycp + * @return boolean true on success */ - global define string mergeDevPath (list devpth) ``{ - if (substring (devpth[1]:"", 0, 1) != "/") - devpth[1] = "/" + devpth[1]:""; - if (devpth[0]:"" == nil || devpth[1]:"" == nil) - return nil; - string ret = devpth[0]:"" + devpth[1]:""; - return ret; + global define boolean grub_updateMBR () ``{ + // FIXME: do the real thing in perl_Bootloader + boolean activate = ( BootCommon::globals["activate"]:"false" == "true" ); + boolean generic_mbr = ( BootCommon::globals["generic_mbr"]:"false" == "true" ); + + y2milestone ("Updating disk system area, activate partition: %1, " + + "install generic boot code in MBR: %2", activate, generic_mbr); + + // After a proposal is done, Bootloader::Propose() always sets + // backup_mbr to true. The default is false. No other parts of the code + // currently change this flag. + if (BootCommon::backup_mbr) + { + y2milestone ("Doing MBR backup: MBR Disk: %1, loader devices: %2", + BootCommon::mbrDisk, BootCommon::GetBootloaderDevices()); + list<string> disks_to_rewrite = (list<string>)toset (merge ( + grub_getMbrsToRewrite (), + merge([BootCommon::mbrDisk], BootCommon::GetBootloaderDevices()))); + y2milestone ("Creating backup of boot sectors of %1", + disks_to_rewrite); + foreach (string d, disks_to_rewrite, { + grub_saveMBR (d); + }); + } + boolean ret = true; + // if the bootloader stage 1 is not installed in the MBR, but + // ConfigureLocation() asked us to replace some problematic existing + // MBR, then overwrite the boot code (only, not the partition list!) in + // the MBR with generic (currently DOS?) bootloader stage1 code + if (generic_mbr && ! contains(BootCommon::GetBootloaderDevices(), BootCommon::mbrDisk)) + { + if (! Stage::initial ()) + { + PackageSystem::Install ("master-boot-code"); + } + y2milestone("Updating code in MBR: MBR Disk: %1, loader devices: %2", + BootCommon::mbrDisk, BootCommon::GetBootloaderDevices()); + list<string> disks_to_rewrite = grub_getMbrsToRewrite (); + foreach (string d, disks_to_rewrite, { + y2milestone ("Copying generic MBR code to %1", d); + string command = sformat ( + "/bin/dd bs=446 count=1 if=%1 of=%2", + "/usr/lib/boot/master-boot-code", + d); + y2milestone ("Running command %1", command); + map out = (map)SCR::Execute (.target.bash_output, command); + integer exit = out["exit"]:0; + y2milestone ("Command output: %1", out); + ret = ret && (0 == exit); + }); + } + + if (activate) + { + foreach (map m_activate, grub_getPartitionsToActivate (), { + any num = m_activate["num"]:0; + string mbr_dev = m_activate["mbr"]:""; + if (num != 0 && mbr_dev != "") + { + // if primary partition + if ((! is (num, integer)) || num <= 4) + { + y2milestone ("Activating partition %1 on %2", num, mbr_dev); + // FIXME: this is the most rotten code since molded sliced bread + // move to bootloader/Core/GRUB.pm or similar + // TESTME: make sure that parted does not destroy BSD + // slices (#suse24740): cf. section 5.1 of "info parted": + // Parted only supports the BSD disk label system. + // Parted is unlikely to support the partition slice + // system in the future because the semantics are rather + // strange, and don't work like "normal" partition tables + // do. + // FIXED: investigate proper handling of the activate flag + // (kernel ioctls in parted etc.) and fix parted + string command = sformat + ("/usr/sbin/parted -s %1 set %2 boot on", mbr_dev, num); + y2milestone ("Running command %1", command); + map out = (map)SCR::Execute (.target.bash_output, command); + integer exit = out["exit"]:0; + y2milestone ("Command output: %1", out); + ret = ret && (0 == exit); + command = sformat ("/usr/sbin/fix_chs %1 %2", + mbr_dev, + num); + y2milestone ("Running command %1", command); + out = (map)SCR::Execute (.target.bash_output, command); + exit = out["exit"]:0; + y2milestone ("Command output: %1", out); + ret = ret && (0 == exit); + } + } + else + { + y2error ("Cannot activate %1", m_activate); + } + }); + } + return ret; + } + + +// -------------------------------------------------------------- +// -------------------------------------------------------------- +// LocationProposal() and related stuff (taken from routines/lilolike.ycp) + + +/** + * Generate device map proposal, store it in internal variables + */ +// copied from src/routines/lilolike.ycp; should be removed there when it is +// not needed there any more (by DisksOrder()), as it is grub only +global void grub_ProposeDeviceMap () { + BootCommon::device_mapping = $[]; + + map targetMap = $[]; + if (Mode::config ()) + y2milestone ("Skipping device map proposing in Config mode"); + else + targetMap = (map)Storage::GetTargetMap(); + +//FIXME: This is not the final solution, we must be able to handle both, +//FakeRAIDs _and_ single disks. + + // Search in complete target map for "CT_DMRAID" types + map DMTargetMap = filter (string k, map v, targetMap, { + return v["type"]:`CT_UNKNOWN==`CT_DMRAID; + }); + + // If no dmraids are present, search in complete target map for "CT_DISK" + // types. This should be the "normal" case. + if ( size(DMTargetMap) == 0 ) { + targetMap = filter (string k, map v, targetMap, { + return v["type"]:`CT_UNKNOWN==`CT_DISK; + }); + } else { + // If dmraid(s) are found, only use them + + // Get all available dmraids in the proper BIOS order + map out = (map) SCR::Execute (.target.bash_output, "dmraid -s -c"); + + if ( out["exit"]:0 == 0 && out["stdout"]:"" != "" ) { + list<string> DMRaid_devices_in_BIOS_order = + splitstring (out["stdout"]:"", "\n"); + + // Remove last list entry (because it is empty) + integer index_empty = size(DMRaid_devices_in_BIOS_order) - 1; + DMRaid_devices_in_BIOS_order = + remove(DMRaid_devices_in_BIOS_order, index_empty); + + integer DMRaidBiosID = 128; + + // FIXME: This code only work when YaST2-Storage either assigns + // BIOS-IDs to all available DMRaid devices or to none of them. + // Probably it's best to throw this code away once YaST2-Storage + // assigns BIOS-IDs to all available DMRaid devices. + + // Assign BIOS-IDs to DMRaid devices in the Target Map in BIOS + // order + DMTargetMap = listmap (string DMRaidDevice, DMRaid_devices_in_BIOS_order, { + DMRaidDevice = "/dev/mapper/" + DMRaidDevice; + if (haskey(DMTargetMap, DMRaidDevice)) { + if ( !haskey(DMTargetMap[DMRaidDevice]:$[], "bios_id") ) { + DMTargetMap[DMRaidDevice, "bios_id"] = tohexstring(DMRaidBiosID); + DMRaidBiosID = DMRaidBiosID + 1; + } + return $[ DMRaidDevice : DMTargetMap[DMRaidDevice]:$[] ]; + } + }); + y2milestone("sorted (according to BIOS) DMTargetMap: %1", DMTargetMap); + } else { + y2error ("Command: \"dmraid -s -c\" failed, no sorting of DMTargetMap."); + } + + targetMap = DMTargetMap; } + + y2milestone ("Target map: %1", targetMap); + + // add devices with known bios_id + // collect BIOS IDs which are used + map ids = $[]; + foreach (string target_dev, map target, targetMap, { + string bios_id = target["bios_id"]:""; + if (bios_id != "") + { + integer index = tointeger (bios_id) - tointeger ("0x80"); + string grub_dev = sformat ("hd%1", index); + BootCommon::device_mapping[target_dev] = grub_dev; + ids[index] = true; + } + }); + // and guess other devices + // don't use already used BIOS IDs + foreach (string target_dev, map target, targetMap, { + string bios_id = target["bios_id"]:""; + if (bios_id == "") + { + integer index = 0; + while (ids[index]:false) + index = index + 1; + string grub_dev = sformat ("hd%1", index); + BootCommon::device_mapping[target_dev] = grub_dev; + ids[index] = true; + } + }); + if (StorageDevices::FloppyPresent) + BootCommon::device_mapping[StorageDevices::FloppyDevice] = "fd0"; + y2milestone ("Detected device mapping: %1", BootCommon::device_mapping); +} + +/** + * SetBootloaderDevice() + * Set "boot_*" flags in the globals map according to the boot device selected + * with parameter selected_location. Only a single boot device can be selected + * with this function. The function cannot be used to set a custom boot device. + * It will always be deleted. + * + * FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these + * decisions are automatic anyway and perl-Bootloader should be able to make + * these decisions without help from the user or the proposal. + * + * @param selected_location symbol one of `boot `root `mbr `extended `mbr_md `none + */ +define void SetBootloaderDevice(symbol selected_location) { + // first, default to all off: + foreach (string flag, ["boot_boot", "boot_root", "boot_mbr"], { + BootCommon::globals[flag] = sformat("%1", false); + }); + // need to remove the boot_custom key to switch this value off + if (haskey (BootCommon::globals, "boot_custom")) { + BootCommon::globals = remove (BootCommon::globals, "boot_custom"); + } + BootCommon::change_widget_default_value("boot_custom", ""); // FIXME: kludge, may be obsolete + + if ( selected_location == `root ) { + BootCommon::globals["boot_root"] = sformat("%1", true); + } else if ( selected_location == `boot ) { + BootCommon::globals["boot_boot"] = sformat("%1", true); + } else if ( selected_location == `mbr ) { + BootCommon::globals["boot_mbr"] = sformat("%1", true); +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// } else if ( selected_location == `extended ) { +// BootCommon::globals["boot_extended"] = sformat("%1", true); +// } else if ( selected_location == `mbr_md ) { +// BootCommon::globals["boot_mbr_md"] = sformat("%1", true); + } +} + +/** + * grub_ConfigureLocation() + * Where to install the bootloader. + * Returns the type of device where to install: one of `boot `root `mbr `extended `mbr_md + * Also sets the boot_* keys in the internal global variable globals accordingly. + * + * Sets internal global variables: + * - boot_* keys in globals map set flags according to the selected bootloader device (currently one of: "boot", "root", "mbr", "mbr_md", "extended") + * - activate key in globals map to true if the partitions for stage 1 need to be "activated" (aka "set bootable") in the MBR + * - activate_changed leave untouched, except when + * - booting from a primary /boot partition on the first disk (the one with the MBR seen by the BIOS), then set to true + * (FIXME: why only then?) + * - generic_mbr key in globals map leave untouched, except when + * - booting from a primary /boot partition on the first disk, then set to true when + * - the examination of the code in the MBR + * - by examine_mbr.pl shows that it + * - DOES NOT look like a valid "stage 1" at all (not enough entropy to contain valid code) OR + * - DOES NOT look like a "generic MBR" (= DOS MBR) (OK as stage 1 to boot primary part. on 1st disk) OR + * - DOES look like a LILO or GRUB MBR (replace them with generic code + * (if stage 1 is not in MBR, see code in updateMBR()), + * they probably contain an obsolete block list for stage 2) OR + * - DOES look like some "stage 1" code (has enough entropy, but no known signature) OR + * - by KeepMBR() -> ThinkPadMBR() shows that it + * - DOES NOT look like a Thinkpad MBR (begins with specific code sequence from that one) + * otherwise set to false + * + * @return string type of location proposed to bootloader + */ +define symbol grub_ConfigureLocation() { + // NOTE: selected_location is a temporary local variable now; the global + // variable is not used for grub anymore + symbol selected_location = `mbr; // default to mbr + + // check whether the /boot partition + // - is primary: is_logical -> false + // - is on the first disk (with the MBR): boot_partition_is_on_mbr_disk -> true + + map tm = Storage::GetTargetMap (); + map dp = Storage::GetDiskPartition (BootCommon::BootPartitionDevice); + string boot_partition_disk = dp["disk"]:""; + boolean boot_partition_is_on_mbr_disk = + (boot_partition_disk == BootCommon::mbrDisk); + + map dm = tm[boot_partition_disk]:$[]; + list<map> partitions_on_boot_partition_disk = dm["partitions"]:[]; + boolean is_logical = false; +// string extended = nil; + + // determine the underlying devices for the "/boot" partition (either the + // BootPartitionDevice, or the devices from which the soft-RAID device for + // "/boot" is built) + list<string> underlying_boot_partition_devices = [ BootCommon::BootPartitionDevice ]; + map md_info = BootCommon::Md2Partitions (BootCommon::BootPartitionDevice); + if (md_info != nil && size (md_info) > 0) + { + boot_partition_is_on_mbr_disk = false; + underlying_boot_partition_devices = maplist (string dev, integer bios_id, md_info, { + map pdp = Storage::GetDiskPartition (dev); + string p_disk = pdp["disk"]:""; + if (p_disk == BootCommon::mbrDisk) + boot_partition_is_on_mbr_disk = true; + return dev; + }); + } + y2milestone ("Boot partition devices: %1", underlying_boot_partition_devices); + + foreach (map p, partitions_on_boot_partition_disk, { +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// if (p["type"]:nil == `extended) +// { +// extended = (string)p["device"]:nil; +// } +// else if (contains (underlying_boot_partition_devices, p["device"]:"") + if (contains (underlying_boot_partition_devices, p["device"]:"") + && p["type"]:nil == `logical) + { + // If any of the underlying_boot_partition_devices can be found on + // the boot_partition_disk AND is a logical partition, set + // is_logical to true. + // For soft-RAID this will not match anyway ("/dev/[hs]da*" does not + // match "/dev/md*"). + is_logical = true; + } + }); + y2milestone ("/boot is on 1st disk: %1", boot_partition_is_on_mbr_disk); + y2milestone ("/boot is in logical partition: %1", is_logical); +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// y2milestone ("The extended partition: %1", extended); + + // keep_mbr, if the MBR contains special code that needs to be kept, + // like Thinkpad boot code (and ATM only Thinkpad boot code + // is recognized) + boolean keep_mbr = BootCommon::KeepMBR (BootCommon::mbrDisk); + + // if is primary, store bootloader there + if (boot_partition_is_on_mbr_disk && ! is_logical) + { + selected_location = `boot; + BootCommon::globals["activate"] = "true"; + BootCommon::activate_changed = true; + // examine_mbr.pl returns + // - != 0 for a read error: "cannot read 512 bytes from <dev>" + // - 1 for an "invalid MBR", i.e. without enough entropy to + // contain boot code + // - 0 for a "Generic MBR" (DOS MBR) + // - 1 for a GRUB or lilo "stage 1" + // - 0 for an unknown MBR + map out = (map)SCR::Execute (.target.bash_output, sformat ( + "/usr/lib/YaST2/bin/examine_mbr.pl %1", boot_partition_disk)); + y2milestone ("MBR examining script returned %1", out); + integer exit = out["exit"]:0; + BootCommon::globals["generic_mbr"] = ((exit != 0) && (! keep_mbr)) ? "true" : "false"; + } + else if (size (underlying_boot_partition_devices) > 1) + { +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// In one or two places yast2-bootloader needs to find out all underlying MBR +// devices, if we install stage 1 to a soft-RAID. These places need to find out +// themselves if we have MBRs on a soft-RAID or not. + // selected_location = `mbr_md; + selected_location = `mbr; + } + + if (keep_mbr) + { +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// if (is_logical && extended != nil) +// selected_location = `extended; +// else + selected_location = `boot; + } + + SetBootloaderDevice(selected_location); + if (! contains (BootCommon::getPartitionList (`boot), (BootCommon::GetBootloaderDevices())[0]:nil)) + { + selected_location = `mbr; // default to mbr + SetBootloaderDevice(selected_location); + } + + y2milestone ("grub_ConfigureLocation (%1 on %2)", + selected_location, BootCommon::GetBootloaderDevices()); + + // set active flag, if needed + if (selected_location == `mbr && size (underlying_boot_partition_devices) <= 1) + { + // We are installing into MBR: + // If there is an active partition, then we do not need to activate + // one (otherwise we do). + // Reason: if we use our own MBR code, we do not rely on the activate + // flag in the partition table to boot Linux. Thus, the activated + // partition can remain activated, which causes less problems with + // other installed OSes like Windows (older versions assign the C: + // drive letter to the activated partition). + BootCommon::globals["activate"] = + (size (Storage::GetBootPartition (BootCommon::mbrDisk)) == 0) ? "true" : "false"; + } + else + { + // if not installing to MBR, always activate (so the generic MBR will + // boot Linux) + BootCommon::globals["activate"] = "true"; + } + + return selected_location; +} + +/** + * Detect "/boot", "/" (root) and extended partition devices and MBR disk + * device + * If no bootloader device has been set up yet (globals["boot_*"]), or the + * first (FIXME(!)) device is not available as a boot partition, also call + * grub_ConfigureLocation to configure globals["boot_*"] and set the + * globals["activate"] and globals["generic_mbr"] flags if needed + * all these settings are stored in internal variables + */ +define void grub_DetectDisks () { + // #151501: AutoYaST also needs to know the activate flag and the + // "boot_*" settings (formerly the loader_device); jsrain also said + // that skipping setting these variables is probably a bug: + // commenting out the skip code, but this may need to be changed and made dependent + // on a "clone" flag (i.e. make the choice to provide minimal (i.e. let + // YaST do partial proposals on the target system) or maximal (i.e. + // stay as closely as possible to this system) info in the AutoYaST XML + // file) + // if (Mode::config ()) + // return; + map mp = Storage::GetMountPoints(); + + list mountdata_boot = mp["/boot"]:(mp["/"]:[]); + list mountdata_root = mp["/"]:[]; + + y2milestone( "mountPoints %1", mp ); + y2milestone( "mountdata_boot %1", mountdata_boot ); + + BootCommon::RootPartitionDevice = mp["/", 0]:""; + + if (BootCommon::RootPartitionDevice == "") + { + y2error ("No mountpoint for / !!"); + } + + // if /boot changed, re-configure location + BootCommon::BootPartitionDevice + = mountdata_boot[0]:BootCommon::RootPartitionDevice; + +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// map tm = Storage::GetTargetMap (); +// map dp = Storage::GetDiskPartition (BootCommon::BootPartitionDevice); +// string disk = dp["disk"]:""; +// map dm = tm[disk]:$[]; +// list<map> partitions = dm["partitions"]:[]; +// foreach (map p, partitions, { +// if (p["type"]:nil == `extended) +// { +// BootCommon::ExtendedPartitionDevice = +// (string)p["device"]:nil; +// } +// }); + + if (BootCommon::mbrDisk == "" || BootCommon::mbrDisk == nil) + { + // mbr detection. + BootCommon::mbrDisk = BootCommon::FindMBRDisk(); + } + + list<string> bldevs = BootCommon::GetBootloaderDevices(); + if (bldevs == nil || bldevs == ["/dev/null"] + // FIXME: check for all bldevs that they are still available + || ! contains (BootCommon::getPartitionList (`boot), bldevs[0]:nil)) + grub_ConfigureLocation (); +} + +/** + * Check whether disk settings were changed since last checking + * @return boolean true if needs to recheck + */ +define boolean grub_DisksChanged () { + if (Mode::config ()) + return false; + map mp = Storage::GetMountPoints(); + string actual_root = mp["/", 0]:""; + string actual_boot = mp["/boot", 0]:actual_root; + + // FIXME: improve comment + // don't change configuration if '/' and '/boot' were not changed + // and location is "floppy", "mbr" or "boot" + if (actual_boot == BootCommon::BootPartitionDevice + && actual_root == BootCommon::RootPartitionDevice + && ! haskey( BootCommon::globals, "boot_custom") + && ( + BootCommon::globals["boot_root"]:"false" == "true" || + BootCommon::globals["boot_boot"]:"false" == "true" || + BootCommon::globals["boot_mbr"]:"false" == "true" +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// BootCommon::globals["boot_extended"]:"false" == "true" || +// BootCommon::globals["boot_mbr_md"]:"false" == "true" + ) + ) + { + return false; + } + + list all_partitions = BootCommon::getPartitionList(`boot); + + if (!contains(all_partitions, (BootCommon::GetBootloaderDevices())[0]:nil)) + { + y2milestone ("Location should be set again"); + return true; + } + return false; +} + +/** + * Propose the boot loader location for grub + */ +define void grub_LocationProposal () { + if (! BootCommon::was_proposed) + { + grub_DetectDisks (); + BootCommon::del_parts = BootCommon::getPartitionList (`deleted); + // check whether edd is loaded; if not: load it + string lsmod_command = "lsmod | grep edd"; + y2milestone ("Running command %1", lsmod_command); + map lsmod_out = (map)SCR::Execute (.target.bash_output, lsmod_command); + y2milestone ("Command output: %1", lsmod_out); + boolean edd_loaded = lsmod_out["exit"]:0 == 0; + if (! edd_loaded) + { + string command = "/sbin/modprobe edd"; + y2milestone ("Loading EDD module, running %1", command); + map out = (map)SCR::Execute (.target.bash_output, command); + y2milestone ("Command output: %1", out); + } + } + + // refresh device map + if (BootCommon::device_mapping == nil + || size (BootCommon::device_mapping) == 0) + { + grub_ProposeDeviceMap (); + } + + if (grub_DisksChanged () && ! Mode::autoinst ()) { + if (BootCommon::askLocationResetPopup ((BootCommon::GetBootloaderDevices())[0]:nil)) { + SetBootloaderDevice(`none); + y2milestone ("Reconfiguring locations"); + grub_DetectDisks (); + } + } +} + +// -------------------------------------------------------------- +// -------------------------------------------------------------- +// other stuff + +/** + * Propose whether allow or not embedding of 1.5 stage + * @return boolean true to allow + */ +// FIXME: remove this function, it is obsolete (now handled within grub by +// using "setup" instead of "install") +// The code probably does not work with multiple bootloader locations anyway. +// This code previously existed in lilolike.ycp and in grub/misc.ycp... See +// more in lilolike.ycp. +define boolean allowEmbed15 () { + // allow only if /boot, /root or MBR device selected + if (! (BootCommon::globals["boot_boot"]:"false" == "true" + || BootCommon::globals["boot_root"]:"false" == "true" + || BootCommon::globals["boot_mbr"]:"false" == "true" + )) + { + return false; + } + // check filesystem on /boot for Reiserfs and JFS + map mp = Storage::GetMountPoints (); + list bp_info + = mp["/boot"]:mp["/"]:[]; + list<map> partitions + = Storage::GetTargetMap ()[bp_info[2]:"", "partitions"]:[]; + boolean ret = false; + foreach (map p, partitions, { + if (p["device"]:"" == BootCommon::BootPartitionDevice) + { + symbol fs = (symbol)p["used_fs"]:nil; + if (fs == `reiser || fs == `jfs) + ret = true; + } + }); + return ret; +} + +/** + * Encrypt the password before storing it in variables + * @param passwd string unencrypted password + * @return string password in the form to write to GRUB's menu.lst + */ +global define string updatePasswdBeforeSave (string passwd) ``{ + passwd = sformat ("--md5 %1", cryptmd5 (passwd)); + return passwd; +} + +/** + * translate filename path (eg. (hd0,0)/kernel) to list of device + * and relative path + * @param devpth string fileststem path (eg. (hd0,0)/vmlinuz) + * @return a list containing device and relative path, + * eg. ["(hd0,0)", "/vmlinuz"] + */ +// FIXME: this should never happen but handled through perl-Bootloader completely +global define list<string> splitDevPath (string devpth) ``{ + y2milestone("FIXME: called splitDevPath(%1) which points to a bug in perl-Bootloader", + devpth); + integer brake = nil; + if (devpth != nil && issubstring (devpth, ")")) + brake = findfirstof (devpth, ")") + 1; + list<string> ret = []; + if (brake != nil) + { + ret[0] = substring (devpth, 0, brake); + ret[1] = substring (devpth, brake); + } + else + { + ret[0] = nil; + ret[1] = devpth; + } + return ret; +} + +/** + * translate list of device and relative path + * to filename path (eg. (hd0,0)/kernel) + * @param devpth list of two strings, first for device name, second for + * relative path (eg. ["(hd0,0)", "/vmlinuz"]) + * @return string fileststem path (eg. (hd0,0)/vmlinuz) + */ +global define string mergeDevPath (list devpth) ``{ + if (substring (devpth[1]:"", 0, 1) != "/") + devpth[1] = "/" + devpth[1]:""; + if (devpth[0]:"" == nil || devpth[1]:"" == nil) + return nil; + string ret = devpth[0]:"" + devpth[1]:""; + return ret; +} } /* Modified: trunk/bootloader/src/modules/BootCommon.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/modules/BootCommon.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/modules/BootCommon.ycp (original) +++ trunk/bootloader/src/modules/BootCommon.ycp Tue Jul 10 22:37:55 2007 @@ -68,8 +68,12 @@ /** * device to save loader stage 1 to + * NOTE: this variable is being phased out. The boot_* keys in the globals map + * are now used to remember the selected boot location. Thus, we now have a + * list of selected loader devices. It can be generated from the information in + * the boot_* keys and the global variables (Boot|Root|Extended)PartitionDevice + * and mbrDisk by calling GetBootloaderDevices(). */ -// FIXME: what is this variable needed for global string loader_device = nil; /** @@ -80,6 +84,8 @@ * information, see the grub documentation, esp. * "info '(grub.info.gz)Bootstrap tricks'" * "info '(grub.info.gz)Images'" + * FIXME: phase this variable out. It is not used any more. GRUB stages are now + * installed with the "setup" command that handles embed_stage15 internally. */ // This needs to be defined here so that various files can include it. // BootCommon.ycp is currently the only central include file, separate include @@ -92,8 +98,10 @@ /** * The kind of bootloader location that the user selected last time he went to - * the dialog. Used to as a hint next time a proposal is requested, so the + * the dialog. Used as a hint next time a proposal is requested, so the * proposal can try to satisfy the user's previous preference. + * NOTE: this variable is being phased out. The boot_* keys in the globals map + * will be used to remember the last selected location. * Currently, valid values are: mbr, boot, root, floppy, mbr_md, none */ global string selected_location = nil; @@ -114,6 +122,14 @@ global string RootPartitionDevice = ""; /** + * string representing device name of extended partition + */ +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +//global string ExtendedPartitionDevice = ""; + +/** * Parameters of currently used bootloader */ global map current_bootloader_attribs = $[]; @@ -554,10 +570,13 @@ map exp = $[ "global": globals, "sections" : sections, - "repl_mbr" : repl_mbr, - "activate" : activate, "device_map" : device_mapping, ]; + if ( ! ( loader_type == "grub" ) ) { + exp["repl_mbr"] = repl_mbr; + exp["activate"] = activate; + } + return exp; } @@ -569,8 +588,13 @@ global define boolean Import (map settings) { globals = settings["global"]:$[]; sections = settings["sections"]:[]; - repl_mbr = settings["repl_mbr"]:false; - activate = settings["activate"]:false; + // FIXME: for grub, repl_mbr is replaced by globals["generic_mbr"]; same + // for activate; remove the following when no bootloader uses these + // variables any more + if ( ! ( loader_type == "grub" ) ) { + repl_mbr = settings["repl_mbr"]:false; + activate = settings["activate"]:false; + } device_mapping = settings["device_map"]:$[]; return true; } @@ -601,6 +625,14 @@ } }); + // convert custom boot device names in globals to the kernel device names + globals = mapmap (string k , string v, globals, { + if ( regexpmatch(k, "^boot_.*custom$" ) ) + return $[k : BootCommon::MountByDev2Dev(v)]; + else + return $[k : v]; + }); + // convert root device names in sections to kernel device names, if // possible sections = maplist (map s, sections, { Modified: trunk/bootloader/src/modules/BootGRUB.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/modules/BootGRUB.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/modules/BootGRUB.ycp (original) +++ trunk/bootloader/src/modules/BootGRUB.ycp Tue Jul 10 22:37:55 2007 @@ -388,7 +388,7 @@ if (reread) { BootCommon::ReadFiles (); } - BootCommon::DetectDisks (); + grub_DetectDisks (); boolean ret = BootCommon::Read (false); // refresh device map if not read if (BootCommon::device_mapping == nil @@ -397,6 +397,13 @@ BootCommon::ProposeDeviceMap (); } + // FIXME: This code can probably be removed. perl-Bootloader sets boot_* + // flags in the globals map. That is all the UI and the proposal code deal + // with. The decision to install the bootloader stage 1 on multiple devices + // (for softraid, dmraid etc.) can be based on the information in the + // boot_{root,boot,mbr} flags and the disk, partitioning and md information + // alone. Thus, perl-Bootloader is able to do this. +/* list<string> loader_devices = splitstring ( BootCommon::globals["stage1_dev"]:"", ","); @@ -478,6 +485,7 @@ { BootCommon::loader_device = loader_devices[0]:""; } +*/ importMetaData(); @@ -502,15 +510,13 @@ y2debug ("Started propose: Glob: %1, Sec: %2", BootCommon::globals, BootCommon::sections); - string old_loader_device = BootCommon::loader_device; // if NOT was_proposed (i.e. blPropose() has not been called yet), then // - set up BootPartitionDevice, RootPartitionDevice // - if empty, set up mbrDisk // - if loader_device is empty or the device is not a boot device, go - // to ConfigureLocation() and + // to grub_ConfigureLocation() and // - propose - // - loader_device - // - selected_location (according to loader_device) + // - select one loader device in the boot_* keys of the globals map // - activate (when needed, but try to be nice to Windows) // - do not touch these, except when /boot partition is selected_location: // - activate_changed (set to true) @@ -526,46 +532,12 @@ // // if '/' and '/boot' were changed and selected_location is set and not // "custom", ask user with popup whether it is OK to change the - // location and change it (with DetectDisks() and ConfigureLocation() + // location and change it (with grub_DetectDisks() and grub_ConfigureLocation() // (see above)) - BootCommon::i386LocationProposal (); - - // The Propose() function is called every time before Summary() is - // called. We have to take the current state of the boot_* and activate - // keys from the globals variable (where the new generic widgets put - // the current settings and/or a previous proposal left them there, see - // below) and put this information in the loader_device and activate - // variables for the internal routines to use. - // FIXME: This should probably be put in a function of its own. ATM, - // this code looks still too specific to put it in a function, though. - // But I may be wrong here. - - if ( old_loader_device == BootCommon::loader_device ) { - // if we did not re-propose, use user-supplied settings (if any) - if ( haskey(BootCommon::globals, "boot_boot") && BootCommon::globals["boot_boot"]:"false" == "true" ) { - BootCommon::loader_device = BootCommon::BootPartitionDevice; - } else if ( haskey(BootCommon::globals, "boot_root") && BootCommon::globals["boot_root"]:"false" == "true" ) { - BootCommon::loader_device = BootCommon::RootPartitionDevice; - } else if ( haskey(BootCommon::globals, "boot_mbr") && BootCommon::globals["boot_mbr"]:"false" == "true" ) { - BootCommon::loader_device = BootCommon::mbrDisk; - } else if ( haskey(BootCommon::globals, "boot_custom") ) { - BootCommon::loader_device = BootCommon::globals["boot_custom"]:""; - } + grub_LocationProposal (); - if ( haskey(BootCommon::globals, "activate") ) { - if ( BootCommon::globals["activate"]:"false" == "true" ) { - BootCommon::activate = true; - } else { - BootCommon::activate = false; - } - } - } - else { - BootCommon::globals["activate"] = - BootCommon::activate ? "true" : "false"; - BootCommon::globals["generic_mbr"] = - BootCommon::repl_mbr ? "true" : "false"; - } + // Note that the Propose() function is called every time before + // Summary() is called. if (BootCommon::sections == nil || size (BootCommon::sections) == 0) { @@ -605,34 +577,6 @@ BootCommon::FixGlobals (); } - // FIXME: The setting of the boot_* and activate keys in globals for - // the new perl-Bootloader interface should probably be put in a - // function of its own. ATM, this code looks still too specific to put - // it in a function, though. But I may be wrong here. - // Pass down proposal to the variables of the new perl-Bootloader code - // first, default to all off: - BootCommon::globals["boot_boot"] = sformat("%1", false); - BootCommon::globals["boot_root"] = sformat("%1", false); - BootCommon::globals["boot_mbr"] = sformat("%1", false); - // need to remove the boot_custom key to switch this value off - if (haskey (BootCommon::globals, "boot_custom")) { - BootCommon::globals = remove (BootCommon::globals, "boot_custom"); - } - BootCommon::change_widget_default_value("boot_custom", ""); // FIXME: kludge, maybe obsolete - - if ( BootCommon::loader_device == BootCommon::RootPartitionDevice ) { - BootCommon::globals["boot_root"] = sformat("%1", true); - } else if ( BootCommon::loader_device == BootCommon::BootPartitionDevice ) { - BootCommon::globals["boot_boot"] = sformat("%1", true); - } else if ( BootCommon::loader_device == BootCommon::mbrDisk ) { - BootCommon::globals["boot_mbr"] = sformat("%1", true); - } else { - BootCommon::globals["boot_custom"] = BootCommon::loader_device; - BootCommon::change_widget_default_value("boot_custom", BootCommon::loader_device); // FIXME: kludge, maybe obsolete - } - - BootCommon::globals["activate"] = sformat("%1", BootCommon::activate); - y2milestone ("Proposed sections: %1", BootCommon::sections); y2milestone ("Proposed globals: %1", BootCommon::globals); } @@ -779,7 +723,7 @@ * @return boolean true on success */ global define boolean Write () ``{ - BootCommon::updateMBR (); + grub_updateMBR (); boolean ret = BootCommon::UpdateBootloader (); if (BootCommon::location_changed || BootCommon::InstallingToFloppy ()) { if (BootCommon::InstallingToFloppy ()) { Modified: trunk/bootloader/src/modules/BootPOWERLILO.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/modules/BootPOWERLILO.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/modules/BootPOWERLILO.ycp (original) +++ trunk/bootloader/src/modules/BootPOWERLILO.ycp Tue Jul 10 22:37:55 2007 @@ -592,6 +592,7 @@ // not) be helpful to be able to specify boot_* variables in the autoyast // file. This may apply better to the boot_* variables in BootGRUB.ycp // though. + // FIXME: what about loader_location (aka selected_location internally)? BootCommon::loader_device = BootCommon::BootPartitionDevice; BootCommon::activate = true; y2milestone("Boot partition is %1", BootCommon::loader_device); Modified: trunk/bootloader/src/modules/Bootloader.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/modules/Bootloader.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/modules/Bootloader.ycp (original) +++ trunk/bootloader/src/modules/Bootloader.ycp Tue Jul 10 22:37:55 2007 @@ -119,13 +119,19 @@ global define map Export () { ReadOrProposeIfNeeded (); map out = $[ - "loader_device" : BootCommon::loader_device, - "loader_location" : BootCommon::selected_location, "loader_type" : getLoaderType (), "initrd" : Initrd::Export (), "specific" : blExport (), "write_settings" : BootCommon::write_settings, ]; + string loader_type = (string) (out["loader_type"]:nil); + + if ( ! ( loader_type == "grub" ) ) { + // export loader_device and selected_location only for bootloaders + // that have not phased them out yet + out["loader_device"] = BootCommon::loader_device; + out["loader_location"] = BootCommon::selected_location; + } y2milestone ("Exporting settings: %1", out); return out; } @@ -149,12 +155,20 @@ BootCommon::setLoaderType (loader_type); BootCommon::getLoaderType (false); - BootCommon::loader_device = settings["loader_device"]:""; - BootCommon::selected_location = settings["loader_location"]:"custom"; - if (loader_type == "lilo" || loader_type == "grub" - || Arch::i386 () || Arch::x86_64 ()) - { - BootCommon::loader_device = BootCommon::GetBootloaderDevice (); + if ( ! ( loader_type == "grub" ) ) { + // import loader_device and selected_location only for bootloaders + // that have not phased them out yet + BootCommon::loader_device = settings["loader_device"]:""; + BootCommon::selected_location = settings["loader_location"]:"custom"; + // FIXME: obsolete for grub (but inactive through the outer "if" now anyway): + // for lilo and grub, always correct the bootloader device according to + // selected_location (or fall back to value of loader_device) + // Why only for lilo and grub? + if (loader_type == "lilo" || loader_type == "grub" + || Arch::i386 () || Arch::x86_64 ()) + { + BootCommon::loader_device = BootCommon::GetBootloaderDevice (); + } } if (settings["initrd"]:$[] != nil) Modified: trunk/bootloader/src/ppc/helps.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/ppc/helps.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/ppc/helps.ycp (original) +++ trunk/bootloader/src/ppc/helps.ycp Tue Jul 10 22:37:55 2007 @@ -25,35 +25,35 @@ global map ppc_descriptions = $[ - "boot" : ( BootCommon::exports["$arch"]:"" == "iseries" ) + "boot" : ( BootCommon::exports["$arch"]:"" == "iseries" ) ? _("iSeries Boot Image Location") : _("PPC Boot Loader Location"), - "activate" : _("Change Boot Device in NV-RAM"), - "timeout" : _("Time-Out in Tenths of Seconds"), - "default" : _("Default Boot Section"), - "root" : _("Default Root Device"), - "append" : _("Append Options for Kernel Command Line"), - "initrd" : _("Default initrd Path"), - "clone" : _("Partition for Boot Loader Duplication"), - "force_fat" : _("Always Boot from FAT Partition"), - "no_os_chooser" : _("Do not use OS-chooser"), - "force" : _("Install Boot Loader Even on Errors"), + "activate" : _("Change Boot Device in NV-RAM"), + "timeout" : _("Time-Out in Tenths of Seconds"), + "default" : _("Default Boot Section"), + "root" : _("Default Root Device"), + "append" : _("Append Options for Kernel Command Line"), + "initrd" : _("Default initrd Path"), + "clone" : _("Partition for Boot Loader Duplication"), + "force_fat" : _("Always Boot from FAT Partition"), + "no_os_chooser" : _("Do not use OS-chooser"), + "force" : _("Install Boot Loader Even on Errors"), "boot_chrp_custom" : _("PReP or FAT Partition"), - "bootfolder" : _("Boot Folder Path"), + "bootfolder" : _("Boot Folder Path"), "boot_prep_custom" : _("PReP Partition"), - "boot_slot" : _("Write to Boot Slot"), - "boot_file" : _("Create Boot Image in File"), + "boot_slot" : _("Write to Boot Slot"), + "boot_file" : _("Create Boot Image in File"), "boot_iseries_custom": _("PReP Partition"), "boot_pmac_custom" : _("HFS Boot Partition"), "type_image" : _("Kernel Section"), "image_image" : _("Kernel Image"), - "image_root" : _("Root Device"), - "image_append" : _("Optional Kernel Command Line Parameter"), - "image_initrd" : _("Initial RAM Disk"), - "image_copy" : _("Copy Image to Boot Partition"), + "image_root" : _("Root Device"), + "image_append" : _("Optional Kernel Command Line Parameter"), + "image_initrd" : _("Initial RAM Disk"), + "image_copy" : _("Copy Image to Boot Partition"), "image_optional" : _("Skip Section gracefully on Errors"), "type_other" : _("Boot Other System"), - "other_other" : _("Boot Partition of Other System"), + "other_other" : _("Boot Partition of Other System"), ]; Modified: trunk/bootloader/src/routines/autoinstall.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/routines/autoinstall.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/routines/autoinstall.ycp (original) +++ trunk/bootloader/src/routines/autoinstall.ycp Tue Jul 10 22:37:55 2007 @@ -105,6 +105,9 @@ // LILO and GRUB stuff if (ai["loader_type"]:"" == "lilo" || ai["loader_type"]:"" == "grub") { + // NOTE: repl_mbr and activate have an effect for lilo, for grub + // they are ignored (we use globals["generic_mbr"] and + // globals["activate"] there) foreach (string k, ["repl_mbr", "activate", ], { if (haskey (ai, k)) @@ -113,6 +116,9 @@ } }); // loader_location needs other default and key + // NOTE: loader_device and loader_location (aka selected_location + // internally) have an effect for lilo, for grub they are ignored + // (we use globals["boot_*"] for these functions there) exp["loader_location"] = ai["location"]:"custom"; foreach (string k, [/*"loader_location",*/ "loader_device"], { if (haskey (ai, k)) @@ -328,6 +334,9 @@ // LILO and GRUB stuff if (ai["loader_type"]:"" == "lilo" || ai["loader_type"]:"" == "grub") { + // FIXME: repl_mbr and activate are obsolete for GRUB, no need to + // look for them in the export map any more (but does not really do + // any harm) foreach (string k, ["repl_mbr", "activate", ], { if (haskey (exp["specific"]:$[], k)) @@ -335,6 +344,9 @@ ai[k] = exp["specific", k]:nil; } }); + // FIXME: loader_device and loader_location (aka selected_location + // internally) are obsolete for GRUB, no need to look for them in + // the export map any more (but does not really do any harm) if (haskey (exp, "loader_location")) ai["location"] = exp["loader_location"]:""; foreach (string k, ["loader_device"], { Modified: trunk/bootloader/src/routines/lilolike.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/routines/lilolike.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/routines/lilolike.ycp (original) +++ trunk/bootloader/src/routines/lilolike.ycp Tue Jul 10 22:37:55 2007 @@ -36,11 +36,19 @@ * Is embedding 1.5 stage of bootloader to dedicated partition area possible? * @return true if it is possible */ +// FIXME: remove this function, it is obsolete (now handled within grub by +// using "setup" instead of "install") +// The code probably does not work with multiple bootloader locations anyway. +// Keeping this temporarily until no other code references it anymore (so that +// for now, the code compiles). This is only used from widget code, and that +// code is probably obsolete as well. +// This code previously existed in lilolike.ycp and in grub/misc.ycp... global boolean allowEmbed15 () { - // allow only for /boot or /root device selected - if (! (BootCommon::loader_device == BootCommon::BootPartitionDevice - || BootCommon::loader_device == BootCommon::RootPartitionDevice - || BootCommon::loader_device == BootCommon::mbrDisk + // allow only if /boot, /root or MBR device selected + // (corrected anyway to use boot_* keys; only grub knows about embed_1.5) + if (! (BootCommon::globals["boot_boot"]:"false" == "true" + || BootCommon::globals["boot_root"]:"false" == "true" + || BootCommon::globals["boot_mbr"]:"false" == "true" )) { return false; @@ -99,7 +107,7 @@ * try to find the system's mbr device * @return string mbr device */ -string FindMBRDisk() { +global string FindMBRDisk() { // check the disks order, first has MBR list<string> order = DisksOrder (); if (size (order) > 0) @@ -145,6 +153,8 @@ * * @return string type of location proposed to bootloader */ + // FIXME: replace with grub_ConfigureLocation() when lilo et al. have + // changed to stop using selected_location and loader_device. string ConfigureLocation() { selected_location = "mbr"; // default to mbr loader_device = BootCommon::mbrDisk; @@ -313,7 +323,7 @@ foreach (string disk, any descr_a, tm, ``{ map descr = (map)descr_a; string bios_id_str = descr["bios_id"]:""; - integer bios_id = 128; // maximum + 1 + integer bios_id = 256; // maximum + 1 (means: no bios_id found) if (bios_id_str != "") bios_id = tointeger (bios_id); list > partitions = (list >) @@ -946,7 +956,8 @@ /** * Generate device map proposal, store it in internal variables */ -// FIXME: move that funbction out here, as it is grub only +// FIXME: remove that function from here, as it is grub only +// NOTE: there is a local copy in routines/grub/misc.ycp now global void ProposeDeviceMap () { device_mapping = $[]; Modified: trunk/bootloader/src/routines/misc.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/routines/misc.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/routines/misc.ycp (original) +++ trunk/bootloader/src/routines/misc.ycp Tue Jul 10 22:37:55 2007 @@ -591,9 +591,11 @@ return [dev, pth]; } - /** * Get bootloader device for specified location + * FIXME: this function is being phased out. Keeping it around until + * selected_location and loader_device can be dropped for all bootloader + * types. * @return string device name */ global define string GetBootloaderDevice () ``{ @@ -612,6 +614,79 @@ return BootCommon::loader_device; } + /** + * Get bootloader devices for specified locations + * @return list device names + */ + global define list<string> GetBootloaderDevices () ``{ + list<string> ret = []; + if (BootCommon::globals["boot_boot"]:"false" == "true") { + ret = add(ret, BootCommon::BootPartitionDevice); + } + if (BootCommon::globals["boot_root"]:"false" == "true") { + ret = add(ret, BootCommon::RootPartitionDevice); + } + if (BootCommon::globals["boot_mbr"]:"false" == "true") { + ret = add(ret, BootCommon::mbrDisk); + } +// FIXME: `extended and `mbr_md are probably unneeded; AFA we can see, these +// decisions are automatic anyway and perl-Bootloader should be able to make +// these decisions without help from the user or the proposal. +// if (BootCommon::globals["boot_mbr_md"]:"false" == "true") { + // FIXME: make this work; this code was copied from + // BootGRUB::Save(), where it was commented out (changes in + // perl-Bootloader are pending) + // get the list of device names to install the boot loader stage 1 into: + // - for non-md devices, use just the device name + // - for installation to md arrays: get the list of device names from + // name of md array, either + // - just the container-partitions (according to yast2-storage) or + // ("/dev/md0" -> ["/dev/hda1", ...]) + // - the (cut off) name of the corresponding disk devices + // ("/dev/md0" -> ["/dev/hda1", ...] -> ["/dev/hda", ...]) + // list dev_lists = maplist (string d, loader_devices, { + // if (substring (d, 0, 7) == "/dev/md") + // { + // map md = BootCommon::Md2Partitions (d); + // if (Mode::test ()) + // md = $["/dev/hda1" : 128, "/dev/hdb1" : 129]; + // return maplist (string d, integer b, md, { + // return d; + // }); + // } + // if (d == "mbr_md") + // { + // map md = BootCommon::Md2Partitions + // (BootCommon::BootPartitionDevice); + // if (Mode::test ()) + // md = $["/dev/hda1" : 128, "/dev/hdb1" : 129]; + // return maplist (string d, integer b, md, { + // // get disk device name for this partition or disk device name + // map p_dev = Storage::GetDiskPartition (d); + // return p_dev["disk"]:""; + // }); + // } + // return [d]; + // }); + // ret = add(ret, BootCommon::mbrDisk); +// } +// if ( haskey(BootCommon::globals, "boot_extended") && +// BootCommon::globals["boot_extended"]:"false" == "true" ) { +// ret = add(ret, BootCommon::ExtendedPartitionDevice); +// } + // FIXME: floppy support is probably obsolete + if ( haskey(BootCommon::globals, "boot_floppy") && + BootCommon::globals["boot_floppy"]:"false" == "true" ) { + ret = add(ret, StorageDevices::FloppyDevice); + } + if ( haskey(BootCommon::globals, "boot_custom") ) { + ret = add(ret, BootCommon::globals["boot_custom"]:""); + } + if ( size(ret) > 0 ) + return ret; + // FIXME: find out what the best value is here: nil, [] or ["/dev/null"] + return ["/dev/null"]; + } /** * Check if installation to floppy is performed @@ -758,17 +833,17 @@ /* * convert any value to an integer and return 0 for nonsense - */ - define integer myToInteger(any num_any) { + */ + global integer myToInteger(any num_any) { if (num_any == nil) - return 0; + return 0; if (is (num_any, integer)) return (integer)num_any; if (is (num_any, string)) return (num_any == "") ? 0 : (tointeger((string)num_any) == nil ? 0 : tointeger((string)num_any)); return 0; - } + } /** * Get partition which should be activated if doing it during bl inst. @@ -790,7 +865,7 @@ if (substring (loader_device, 0, 7) == "/dev/md") { map md = Md2Partitions (BootCommon::loader_device); - integer min = 128; // max. is 127 + integer min = 256; // max. is 255; 256 means "no bios_id found" string device = ""; foreach (string d, integer id, md, { if (id < min) @@ -801,7 +876,7 @@ }); if (device != "") { - map p_dev = Storage::GetDiskPartition (loader_device); + map p_dev = Storage::GetDiskPartition (device); num = myToInteger( p_dev["nr"]:nil ); mbr_dev = p_dev["disk"]:""; } Modified: trunk/bootloader/src/routines/popups.ycp URL: http://svn.opensuse.org/viewcvs/yast/trunk/bootloader/src/routines/popups.ycp?rev=39303&r1=39302&r2=39303&view=diff ============================================================================== --- trunk/bootloader/src/routines/popups.ycp (original) +++ trunk/bootloader/src/routines/popups.ycp Tue Jul 10 22:37:55 2007 @@ -142,7 +142,7 @@ * @param device string currently confiogured device * @return boolean yes if shall be reset */ - boolean askLocationResetPopup (string device) ``{ + global boolean askLocationResetPopup (string device) ``{ // yes-no popup return Popup::YesNo(sformat(_("Partition '%1' is not available. Set default boot loader location? @@ -193,6 +193,9 @@ fs = (symbol)UI::QueryWidget (`id (`fs), `Value); } UI::CloseDialog (); + // FIXME: loader_device cannot be used for grub anymore; but this + // function should not be used anymore anyway, because BootFloppy has + // been disabled. string dev = BootCommon::loader_device; if (format) { -- To unsubscribe, e-mail: yast-commit+unsubscribe@opensuse.org For additional commands, e-mail: yast-commit+help@opensuse.org