home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / include / bootloader / routines / lib_iface.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  10.8 KB  |  369 lines
  1. /**
  2.  * File:
  3.  *      include/bootloader/routines/lib-iface.ycp
  4.  *
  5.  * Module:
  6.  *      Bootloader installation and configuration
  7.  *
  8.  * Summary:
  9.  *      Functions to interface the bootloader library
  10.  *
  11.  * Authors:
  12.  *      Jiri Srain <jsrain@suse.cz>
  13.  *
  14.  * $Id: lib_iface.ycp 34433 2006-11-16 16:28:10Z jplack $
  15.  *
  16.  * WARNING:
  17.  *      To be included to BootCommon.ycp only
  18.  *      Use import "BootCommon" instead.
  19.  */
  20.  
  21.  
  22.  
  23. {
  24.  
  25. textdomain "bootloader";
  26.  
  27. import "System::Bootloader_API";
  28. import "Storage";
  29.  
  30. /**
  31.  * Loader the library has been initialized to use
  32.  */
  33. string library_initialized = nil;
  34.  
  35. /**
  36.  *  Retrieve the data for perl-Bootloader library from Storage module
  37.  *  and pass it along
  38.  *  @return nothing
  39.  */
  40. // FIXME: this should be done directly in perl-Bootloader through LibStorage.pm
  41. global void SetDiskInfo () {
  42.     map<string,list<string> > md_info = $[];
  43.     map<string,any> mountpoints = mapmap (string k, list v,
  44.     (map<string,list>)Storage::GetMountPoints (),
  45.     {
  46.         // detect all raid1 md devices and mark them in md_info
  47.         any device = v[0]:nil;
  48.     if (v[3]:"" == "raid1")
  49.        md_info[(string)device]=[];
  50.     return $[ k : device ];
  51.     });
  52.     mountpoints = filter (string k, any v, mountpoints, {
  53.     string tmpdir = (string)SCR::Read (.target.tmpdir);
  54.     integer tmp_sz = size (tmpdir);
  55.     return is (v, string) && substring (k, 0, tmp_sz) != tmpdir;
  56.     });
  57.     if (! Stage::initial ())
  58.     {
  59.         // get what's really mounted
  60.         list<map<string,any> > mounted_list = (list<map<string,any> >)
  61.         SCR::Read (.proc.mounts);
  62.     map<string,string> mounted = listmap (map<string,any> m, mounted_list, {
  63.         return $[ m["file"]:"" : m["spec"]:"" ];
  64.     });
  65.     y2milestone ("Really mounted: %1", mounted);
  66.     mountpoints = filter (string k, any v, mountpoints, {
  67.         return mounted[k]:nil == v;
  68.     });
  69.     }
  70.     y2milestone ("Detected mountpoints: %1", mountpoints);
  71.  
  72.     map<string,map> tm = (map<string,map>)Storage::GetTargetMap ();
  73.     list<list<list> > pi = maplist (string disk, map info, tm,
  74.     {
  75.     if (info["type"]:`CT_UNKNOWN==`CT_LVM)
  76.         return [];
  77.     if (info["type"]:`CT_UNKNOWN==`CT_EVMS)
  78.         return [];
  79.     list partitions = info["partitions"]:[];
  80.     list<list> parts = maplist (map p, (list<map>)partitions, {
  81.         string raid = "";
  82.         if( p["used_by_type"]:`UB_NONE==`UB_MD )
  83.         raid = p["used_by"]:"";
  84.         string device = p["device"]:"";
  85.         // We only pass along RAID1 devices as all other causes
  86.         // severe breakage in the bootloader stack
  87.         if (raid != "") {
  88.             raid = "/dev/" + raid;
  89.         if (haskey (md_info, raid)) {
  90.             list<string> members = md_info[raid]:[];
  91.             members = add (members, device);
  92.             md_info[raid] = members;
  93.         }
  94.         }
  95.         any nr = p["nr"]:nil;
  96.         if (nr == nil)
  97.         nr = 0;
  98.         string nr_str = sformat ("%1", nr);
  99.      /* FIXME: And the other information about the disk ?:
  100.             p["fsid"] = LibStorage::PartitionInfo::swig_id_get(info);
  101.             p["fstype"] = Partitions::FsIdToString( p["fsid"]:0 );
  102.             p["region"] = [ LibStorage::PartitionInfo::swig_cylStart_get(info),
  103.                             LibStorage::PartitionInfo::swig_cylSize_get(info) ];
  104.             p["type"] = toSymbol( conv_ptype, t );
  105.             p["boot"] = true;
  106.       */
  107.  
  108.         return [ device, disk, nr_str, tostring(p["fsid"]:0),
  109.         p["fstype"]:"unknown", tostring(p["type"]:nil),
  110.         tostring(p["region", 0]:0), tostring(p["region", 1]:0)
  111.         ];
  112.     });
  113.     return parts;
  114.     });
  115.     list<list> partinfo = flatten (pi);
  116.     partinfo = filter (list p, partinfo, {return p != nil && p != [];});
  117.     y2milestone ("Information about partitioning: %1", partinfo);
  118.     y2milestone ("Information about MD arrays: %1", md_info);
  119.  
  120.     System::Bootloader_API::setMountPoints ((map<string,string>) mountpoints);
  121.     System::Bootloader_API::setPartitions ((list<list<string> >) partinfo);
  122.     System::Bootloader_API::setMDArrays ((map<string,list<string> >) md_info);
  123. }
  124.  
  125. /**
  126.  * Initialize the bootloader library
  127.  * @param force boolean true if the initialization is to be forced
  128.  * @param loader string the loader to initialize the library for
  129.  * @return boolean true on success
  130.  */
  131. global boolean InitializeLibrary (boolean force, string loader) {
  132.     if (!force && loader == library_initialized)
  133.         return false;
  134.  
  135.     y2milestone ("Initializing lib for %1", loader);
  136.     System::Bootloader_API::setLoaderType (loader);
  137.     y2milestone ("Putting partitioning into library");
  138.     // pass all needed disk/partition information to library
  139.     SetDiskInfo();
  140.     y2milestone ("Library initialization finished");
  141.     library_initialized = loader;
  142.     return true;
  143. }
  144.  
  145. /**
  146.  * Set boot loader sections
  147.  * @param sections a list of all loader sections (as maps)
  148.  * @return boolean true on success
  149.  */
  150. global boolean SetSections (list<map<string,string> > sections) {
  151.     y2milestone ("Storing bootloader sections %1", sections);
  152.     sections = maplist (map<string,string> s, sections, {
  153.     s["__modified"] = "1";
  154.     s = filter (string key, string value, s, {
  155.         return (! is (value, string)) || (value != "");
  156.     });
  157.  
  158.     return s;
  159.     });
  160.     boolean ret = System::Bootloader_API::setSections (sections);
  161.     if (! ret)
  162.     y2error ("Storing bootloader sections failed");
  163.     return ret;
  164. }
  165.  
  166. /**
  167.  * Get boot loader sections
  168.  * @return a list of all loader sections (as maps)
  169.  */
  170. global list<map<string,string> > GetSections () {
  171.     y2milestone ("Reading bootloader sections");
  172.     list<map<string,string> > sects = System::Bootloader_API::getSections ();
  173.     if (sects == nil)
  174.     {
  175.     y2error ("Reading sections failed");
  176.     return [];
  177.     }
  178.     y2milestone ("Read sections: %1", sects);
  179.     return sects;
  180. }
  181.  
  182. /**
  183.  * Set global bootloader options
  184.  * @param globals a map of global bootloader options
  185.  * @return boolean true on success
  186.  */
  187. global boolean SetGlobal (map<string,string> globals) {
  188.     y2milestone ("Storing global settings %1", globals);
  189.     globals["__modified"] = "1";
  190.     boolean ret = System::Bootloader_API::setGlobalSettings (globals);
  191.     if (! ret)
  192.     y2error ("Storing global settings failed");
  193.     return ret;
  194. }
  195.  
  196. /**
  197.  * Get global bootloader options
  198.  * @return a map of global bootloader options
  199.  */
  200. global map<string,string> GetGlobal () {
  201.     y2milestone ("Reading bootloader global settings");
  202.     map<string,string> glob = System::Bootloader_API::getGlobalSettings ();
  203.     if (glob == nil)
  204.     {
  205.     y2error ("Reading global settings failed");
  206.     return $[];
  207.     }
  208.     y2milestone ("Read global settings: %1", glob);
  209.     return glob;
  210. }
  211.  
  212. /**
  213.  * Get bootloader configuration meta data such as field type descriptions
  214.  * @return a map of meta data for global and section entries
  215.  */
  216. global map<string,string> GetMetaData () {
  217.     y2milestone ("Reading meta data for global and section settings");
  218.     // FIXME: DiskInfo should be read directly by perl-Bootloader
  219.     // send current disk/partition information to perl-Bootloader
  220.     SetDiskInfo();
  221.  
  222.     y2milestone ("Calling getMetaData");
  223.     map<string,string> meta = System::Bootloader_API::getMetaData ();
  224.     y2milestone ("Returned from getMetaData");
  225.     if (meta == nil)
  226.     {
  227.     y2error ("Reading meta data failed");
  228.     return $[];
  229.     }
  230.     y2milestone ("Read meta data settings: %1", meta);
  231.     return meta;
  232. }
  233.  
  234. /**
  235.  * Set the device mapping (Linux <-> Firmware)
  236.  * @param device_map a map from Linux device to Firmware device identification
  237.  * @return boolean true on success
  238.  */
  239. global boolean SetDeviceMap (map<string,string> device_map) {
  240.     y2milestone ("Storing device map");
  241.     boolean ret = System::Bootloader_API::setDeviceMapping (device_map);
  242.     if (! ret)
  243.     y2error ("Storing device map failed");
  244.     return ret;
  245. }
  246.  
  247. /**
  248.  * Get the device mapping (Linux <-> Firmware)
  249.  * @return a map from Linux device to Firmware device identification
  250.  */
  251. global map<string,string> GetDeviceMap () {
  252.     y2milestone ("Reading device mapping");
  253.     map<string,string> devmap = System::Bootloader_API::getDeviceMapping ();
  254.     if (devmap == nil)
  255.     {
  256.     y2error ("Reading device mapping failed");
  257.     return $[];
  258.     }
  259.     y2milestone ("Read device mapping: %1", devmap);
  260.     return devmap;
  261. }
  262.  
  263. /*
  264.  * Display the log file written by the underlying bootloader libraries 
  265.  */
  266. global void bootloaderError (string error) {
  267.     string bl_logfile = "/var/log/YaST2/y2log_bootloader";
  268.     string bl_log = (string)SCR::Read (.target.string, bl_logfile);
  269.  
  270.     errorWithLogPopup (
  271.     sformat (
  272.         // error popup - label, %1 is bootloader name
  273.         _("Error occurred while installing %1."),
  274.         BootCommon::getLoaderName (BootCommon::getLoaderType (false), `summary)
  275.     ),
  276.     bl_log
  277.     );
  278.     y2error ("%1", error);
  279. }
  280.  
  281. /**
  282.  * Read the files from the system to internal cache of the library
  283.  * @return boolean true on success
  284.  */
  285. global boolean ReadFiles () {
  286.     y2milestone ("Reading Files");
  287.     boolean ret = System::Bootloader_API::readSettings ();
  288.     if (! ret)
  289.     y2error ("Reading files failed");
  290.     return ret;
  291. }
  292.  
  293. /**
  294.  * Flush the internal cache of the library to the disk
  295.  * @return boolean true on success
  296.  */
  297. global boolean CommitSettings () {
  298.     y2milestone ("Writing files to system");
  299.     boolean ret = System::Bootloader_API::writeSettings ();
  300.     if (! ret)
  301.     bootloaderError ("Writing files to system failed");
  302.     return ret;
  303. }
  304.  
  305. /**
  306.  * Update the bootloader settings, make updated saved settings active
  307.  * @return boolean true on success
  308.  */
  309. global boolean UpdateBootloader () {
  310.     y2milestone ("Updating bootloader configuration");
  311.     boolean ret = System::Bootloader_API::updateBootloader (true);
  312.     y2milestone ("return value from updateBootloader: %1", ret);
  313.     if (! ret)
  314.     bootloaderError ("Error occurred while updating configuration files");
  315.     return ret;
  316. }
  317.  
  318. /**
  319.  * Initialize the boot loader (eg. modify firmware, depending on architecture)
  320.  * @return boolean true on success
  321.  */
  322. global boolean InitializeBootloader () {
  323.     y2milestone ("Initializing bootloader");
  324.     boolean ret = System::Bootloader_API::initializeBootloader ();
  325.     if (! ret)
  326.         bootloaderError ("Error occurred while initializing bootloader");
  327.     return ret;
  328. }
  329.  
  330. /**
  331.  * Get contents of files from the library cache
  332.  * @return a map filename -> contents, empty map in case of fail
  333.  */
  334. global map<string,string> GetFilesContents () {
  335.     y2milestone ("Getting contents of files");
  336.     map<string,string> ret = System::Bootloader_API::getFilesContents ();
  337.     if (ret == nil)
  338.     {
  339.     y2error ("Getting contents of files failed");
  340.     return $[];
  341.     }
  342.     return ret;
  343. }
  344.  
  345. /**
  346.  * Set the contents of all files to library cache
  347.  * @param files a map filename -> contents
  348.  * @return boolean true on success
  349.  */
  350. global boolean SetFilesContents (map<string,string> files) {
  351.     y2milestone ("Storing contents of files");
  352.     boolean ret = System::Bootloader_API::setFilesContents (files);
  353.     if (! ret)
  354.     y2error ("Setting file contents failed");
  355.     return ret;
  356. }
  357.  
  358. } //end of include
  359.  
  360. /*
  361.  * Local variables:
  362.  *     mode: ycp
  363.  *     mode: font-lock
  364.  *     mode: auto-fill
  365.  *     indent-level: 4
  366.  *     fill-column: 78
  367.  * End:
  368.  */
  369.