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 / repair / osr_module_partition.ycp < prev   
Encoding:
Text File  |  2006-11-29  |  55.6 KB  |  1,683 lines
  1. /**
  2.  * File:
  3.  *   osr_module_partition.ycp
  4.  *
  5.  * Module:
  6.  *   Partition and filesystems checking module.
  7.  *
  8.  * Summary:
  9.  *   YaST2 OS Repair. Automatic error detection & repair tool for Linux.
  10.  *
  11.  * Author:
  12.  *   Johannes Buchhold <jbuch@suse.de>
  13.  *
  14.  * $Id: osr_module_partition.ycp 32906 2006-09-15 09:57:06Z jsuchome $
  15.  */
  16.  
  17. {
  18.   import "FileSystems";
  19.   import "Label";
  20.   import "Mode";
  21.   import "OSR";
  22.   import "OSRCommon";
  23.   import "OSRProgress";
  24.   import "OSRSummary";
  25.   import "OSRSystem";
  26.   import "OSRStatus";
  27.   import "OSRExecute";
  28.   import "OSRPtbl";
  29.   import "OSRSwap";
  30.   import "OSRFsck";
  31.   import "OSRFstab";
  32.   import "OSRPopup";
  33.   import "OSRModuleLoading";
  34.   import "Partitions";
  35.   import "Popup";
  36.   import "Report";
  37.   import "Stage";
  38.   import "Storage";
  39.  
  40.   textdomain "repair";
  41.  
  42.   include "partitioning/custom_part_dialogs.ycp";
  43.  
  44.   //////////////////////////////////////////////////////////////////////
  45.   //
  46.   //  DETECTION METHODS
  47.   //
  48.   //////////////////////////////////////////////////////////////////////
  49.  
  50.  
  51.   /**
  52.    * Check if at least one harddisk exist.
  53.    */
  54.   define boolean OSRPartitionCheckDiskCount()``{
  55.  
  56.       /////////////////////////////////////////////////////////////////////////
  57.       //
  58.       //  Check all disks for entries in their map
  59.       //
  60.       /////////////////////////////////////////////////////////////////////////
  61.       Storage::ReReadTargetMap();
  62.  
  63.       // get the names of detected harddisks and put them in the list -> ["/dev/hda", "/dev/sda"]
  64.       map<string,map> tg = filter( string k, map d, Storage::GetTargetMap(), ``(Storage::IsRealDisk(d)));
  65.       list<string> disk_list = maplist( string k, map d, tg, ``(k));
  66.  
  67.       if ((size(disk_list) == 0) || (disk_list == nil))
  68.       {
  69.         // if no harddisk was found, exit the rescue system
  70.         OSRStatus::ErrorSeverityBlocking();
  71.         // summary text
  72.         OSRSummary::DetectError( "", _("No hard disks were detected"));
  73.         // error popup
  74.         Report::Message(_("
  75. Could not detect any hard disks
  76. in your system. You probably need to load
  77. the correct kernel modules.
  78.  
  79. Halting the repair system.
  80. "));
  81.  
  82.         OSR::SetReboot();
  83.         return false;
  84.       }
  85.       else if (size(disk_list) == 1)
  86.       {
  87.         OSRSummary::DetectOK("",
  88.             // summary text: %1 will be replaced with a string like "/dev/hda"
  89.             sformat(_("One hard disk detected: %1"), disk_list[0]:""));
  90.       }
  91.       else if (size(disk_list) > 1)
  92.       {
  93.         OSRSummary::DetectOK("",
  94.             // summary text: %1 is string like "/dev/hda, /dev/hdb, /dev/sda"
  95.             sformat(_("Several hard disks detected: %1"), mergestring(disk_list, ", ")));
  96.       }
  97.       OSRCommon::ProvideBoolean("valid_target",true);
  98.       return true;
  99.   }
  100.  
  101.  
  102.   /**
  103.    *  Checks the mbr's of all harddisks.
  104.    *  @return boolean
  105.    */
  106.   define boolean OSRPartitionCheckDisks() ``{
  107.  
  108.       /////////////////////////////////////////////////////////////////////////
  109.       //
  110.       //  Iterate all harddisks, check for partitions
  111.       //
  112.       /////////////////////////////////////////////////////////////////////////
  113.  
  114.       map           target_map      = Storage::GetTargetMap();
  115.       list<string>  valid_target_list   = [];
  116.  
  117.       // check all targets (all disks) for partition entries
  118.       foreach(string target, map values, (map<string,map>) target_map, ``{
  119.  
  120.       list<map> target_partitions = values["partitions"]:[];
  121.  
  122.       if ( size(target_partitions) == 0 )
  123.       {
  124.           OSRSummary::DetectError("",
  125.             // summary text
  126.             sformat(_("No partition table was found for hard disk %1"),target));
  127.  
  128.           /////////////////////////////////////////////////////////////////////
  129.           //
  130.           //  Repair partition table with backup from floppy or with proposal
  131.           //  from gpart
  132.           //
  133.           /////////////////////////////////////////////////////////////////////
  134.           OSRSummary::SetRepairSummary( OSRPtbl::MainPtblRepairDialog(target),
  135.                 // summary header
  136.                 sformat(_("Repairing partition table of hard disk %1"), target),
  137.                 // summary text
  138.                 _("Successfully repaired the partition table"),
  139.                 // summary text
  140.                 _("Partition table was not repaired"),
  141.                 // summary text
  142.                 _("Repair was not successful"));
  143.       }
  144.       else
  145.       {
  146.           // add the name of the current harddisk to the list of valid targets
  147.           valid_target_list = add(valid_target_list, target);
  148.       }
  149.       });
  150.  
  151.       /////////////////////////////////////////////////////////////////////////
  152.       //
  153.       //  Check if at least one harddisk with a valid partition table exists
  154.       //
  155.       /////////////////////////////////////////////////////////////////////////
  156.  
  157.       if (size(valid_target_list) == 0)
  158.       {
  159.         OSRStatus::ErrorSeverityBlocking();
  160.  
  161.         OSRSummary::DetectError("",
  162.             // summary text
  163.             _("No hard disk was found with a valid primary partition table"));
  164.  
  165.         // error popup
  166.         Report::Message(_("
  167. None of the hard disks detected
  168. contain a valid primary partition table.
  169.  
  170. Halting the repair system.
  171. "));
  172.  
  173.         OSR::SetReboot();
  174.         return false;
  175.       }
  176.       else if (size(valid_target_list) == 1)
  177.       {
  178.         // at least one valid target found
  179.         OSRSummary::DetectOK("",
  180.             // summary text (%1 is disk)
  181.             sformat(_("Partition tables found for disk %1"),
  182.                 valid_target_list[0]:""));
  183.       }
  184.       else if (size(valid_target_list) > 0)
  185.       {
  186.         // at least one valid target found
  187.         OSRSummary::DetectOK( "",
  188.             // summary text
  189.             sformat(_("Partition tables found for the disks %1"),
  190.                 mergestring(valid_target_list, ", ")));
  191.       }
  192.       OSRCommon::ProvideList("valid_target_list", valid_target_list);
  193.       return true;
  194.   };
  195.  
  196.   /**
  197.    *
  198.    */
  199.   define boolean OSRPartitionCheckSwap()``{
  200.       /////////////////////////////////////////////////////////////////
  201.       //
  202.       // search for valid swap partitions
  203.       //
  204.       /////////////////////////////////////////////////////////////////
  205.       list<string> swap_partition_list = OSRSwap::Partitions();
  206.       if ( size( swap_partition_list ) <= 0 )
  207.       {
  208.         // summary text
  209.         OSRSummary::NotFound("", _("No valid partition types were found"));
  210.       }
  211.       else
  212.       {
  213.         OSRSummary::DetectOK("",
  214.             // summary text (%1 are partitions)
  215.             sformat(_("Valid swap partitions were found:<br>%1"),
  216.                 mergestring(swap_partition_list, ", ")));
  217.         OSRCommon::ProvideList("swap_partition_list", swap_partition_list );
  218.       }
  219.       return true;
  220.   }
  221.  
  222.  
  223.   define boolean OSRPartitionCheckSwapAble()``{
  224.  
  225.       /////////////////////////////////////////////////////////////////
  226.       //
  227.       // search for "swap-able" partitions
  228.       //
  229.       /////////////////////////////////////////////////////////////////
  230.       list<string> swap_partition_list     = (list<string>)
  231.     OSRCommon::RequireList("swap_partition_list"); // ["/dev/hda1", "/dev/hdb2"]
  232.       list<string> swapable_partition_list = OSRSwap::ValidPartitions(swap_partition_list); // ["/dev/hdb2"]
  233.       list<string> swapon_notpossible_list = filter(string p, swap_partition_list, ``( ! contains( swapable_partition_list, p )));
  234.  
  235.       if (size( swapable_partition_list ) <= 0 )
  236.       {
  237.         // summary text
  238.         OSRSummary::NotFound("", _("No swap partitions were found"));
  239.       }
  240.       else
  241.       {
  242.         OSRSummary::DetectOK("",
  243.             // summary text (%1 are partitions)
  244.             sformat(_("Swap partitions were found:<br>%1"),
  245.                 mergestring(swapable_partition_list, ", ")));
  246.       }
  247.  
  248.       OSRCommon::ProvideList("swapable_partitions", swapable_partition_list);
  249.  
  250.       /////////////////////////////////////////////////////////////////
  251.       //
  252.       // include all swap partitions
  253.       //
  254.       /////////////////////////////////////////////////////////////////
  255.       foreach(string swap, swapable_partition_list, ``{
  256.  
  257.       // Check if the specified swap-partition is already "swapped", if true don't swapon.
  258.       // summary header (%1 is partition)
  259.       string summary_header = sformat(_("Adding partition %1 to swap"), swap);
  260.  
  261.       if ( Storage::CheckSwapOn(swap))
  262.       {
  263.         OSRSummary::DetectOK( summary_header,
  264.             // summary text (%1 is partition)
  265.             sformat(_("Partition %1 was already added to swap"), swap));
  266.       }
  267.       else
  268.       {
  269.         // popup label (%1 is partition)
  270.         if( ! Popup::YesNoHeadline(sformat(_("Activate Swap Partition %1"), swap),
  271.             // popup text
  272.             sformat(_("
  273. The partition %1 has the file system ID 130 and
  274. contains a valid swap area. Activating this swap
  275. partition increases the performance of the repair tool.
  276. Activate the swap
  277. partition?
  278. "),swap ) ))
  279.           {
  280.             return;
  281.           }
  282.  
  283.           // run /sbin/swapon
  284.           if ( OSRExecute::Command(.local.bash, sformat("/sbin/swapon %1", swap)))
  285.           {
  286.             OSRSummary::DetectOK( summary_header,
  287.                 // summary text
  288.                 _("Swap activation was successful"));
  289.  
  290.             // add spap partition to list swap_aktivated for swapoff
  291.             OSRCommon::ProvideList("swap_aktivated", add (
  292.                 OSRCommon::RequireList("swap_aktivated"), swap ));
  293.           }
  294.           else
  295.           {
  296.             // should never happen - GetSwapablePartitions(swap_partition_list) test swapon !!
  297.             OSRSummary::DetectError( summary_header,
  298.                 // summary text
  299.                 _("Swap activation was not successful"));
  300.           }
  301.       }
  302.       });
  303.  
  304.       if ( size ( swapon_notpossible_list ) != 0 ) {
  305.       foreach(string part, swapon_notpossible_list, ``{
  306.           OSRSummary::DetectError(
  307.                       // summary header
  308.                       sformat(_("Adding partition %1 to swap..."), part),
  309.                       // summary text
  310.                       sformat(_("No valid swap area was found on
  311. partition %1"), part)
  312.                       );
  313.  
  314.           OSRSummary::SetRepairSummary(OSRSwap::Repair( part ),
  315.                       // summary header
  316.                       sformat(_("Creating swap area on partition %1..."), part),
  317.                       // summary text
  318.                       sformat(_("mkswap %1 was successful"), part ),
  319.                       // summary text
  320.                       _("Repair skipped"),
  321.                       // summary text
  322.                       sformat(_("mkswap %1 was not successful"), part ));
  323.       });
  324.       }
  325.       return true;
  326.   }
  327.  
  328.  
  329.   /**
  330.    * Load all kernel fs modules
  331.    */
  332.   define boolean OSRPartitionLoadAllFsModules()``{
  333.  
  334.       /////////////////////////////////////////////////////////
  335.       //
  336.       // install available kernel modules for the filesystems
  337.       //
  338.       /////////////////////////////////////////////////////////
  339.       if (! OSRFsck::LoadAllFsModules())
  340.       {
  341.         OSRSummary::DetectProblem("",
  342.             // summary text (%1 are kernel modules)
  343.             sformat(_("Loading failed for kernel modules:<br> %1"),
  344.                 mergestring(OSRFsck::not_installed_modules, "<br>")));
  345.         return false;
  346.       }
  347.       else {
  348.         OSRSummary::DetectOK("",
  349.             // summary text (%1 are kernel modules)
  350.             sformat(_("Kernel modules successfully installed:<br> %1"),
  351.                 mergestring(OSRFsck::fs_kernel_modules, "<br>")));
  352.         OSRCommon::ProvideBoolean("fs_module_loaded", true);
  353.         return true;
  354.       }
  355.   }
  356.  
  357.   /**
  358.    *
  359.    */
  360.   define boolean OSRPartitionCurrentlyMountedPartitions()``{
  361.  
  362.       /////////////////////////////////////////////////////////
  363.       //
  364.       // Umount all partitions from "/mnt" or from deeper directories
  365.       // (e.g. "/mnt/usr", "/mnt/usr/local", ...)
  366.       // before mounting anything to "/mnt".
  367.       //
  368.       /////////////////////////////////////////////////////////
  369.       //string  root_mountpoint    = OSRCommon::RequireString("root_mountpoint");
  370.       OSRSystem::SetOrgRoot();
  371.       OSRCommon::ProvideList("just_umounted", OSRFstab::UmountAllFrom( OSRSystem::TargetRoot()));
  372.  
  373.       list<map> mounted_partitions = Partitions::CurMounted();
  374.       // filter swap partitions
  375.       mounted_partitions = filter(map p, mounted_partitions,
  376.         ``(p["file"]:"" != "swap" && findfirstof( p["spec"]:"", "/") == 0 ));
  377.  
  378.       /////////////////////////////////////////////////////////
  379.       //
  380.       // search for currently mounted partitions
  381.       //
  382.       /////////////////////////////////////////////////////////
  383.       if ( size( mounted_partitions) <= 0)
  384.       {
  385.         // no mounted partitions: not implicitly an error!
  386.         // summary text
  387.         OSRSummary::DetectOK("", _("No mounted partitions were found"));
  388.       }
  389.       else
  390.       {
  391.         // create a mount-like output
  392.         list<string> mounted_output = maplist(map entry, mounted_partitions,
  393.                     // %1 is device, %2 mount point, %3 is fs type, %4 options
  394.                     // example: "/dev/hda3 on /local type  rw" (=empty type)
  395.                     ``(sformat (_("%1 on %2 type %3 %4"),
  396.                         entry["spec"]:"", entry["file"]:"",
  397.                         entry["fstype"]:"", entry["mntops"]:"")));
  398.         OSRSummary::DetectOK("",
  399.             // summary text
  400.             sformat(_("Mounted partitions were found:<br>%1"),
  401.                 mergestring(mounted_output, "<br>")));
  402.       }
  403.       OSRCommon::ProvideList("mounted_partitions", mounted_partitions);
  404.       return true;
  405.   }
  406.  
  407.   /**
  408.    *
  409.    */
  410.   define boolean OSRPartition2CheckPartitions()``{
  411.  
  412.       /////////////////////////////////////////////////////////
  413.       //
  414.       // search for fsck possible partitions
  415.       //
  416.       /////////////////////////////////////////////////////////
  417.  
  418.       list<map> fs_check_parts = OSRFsck::PossiblePartitions();
  419.  
  420.       if( size( fs_check_parts ) == 0 || fs_check_parts == nil) {
  421.         // summary text
  422.         OSRSummary::DetectError("",_("No partitions found"));
  423.       }
  424.       else {
  425.         list<string> key_list = maplist(map p, fs_check_parts,
  426.             ``( p["device"]:"" ));
  427.         OSRSummary::DetectOK("", sformat("%1", mergestring(key_list, " " )));
  428.       }
  429.       OSRCommon::ProvideList("fsck_partitions", fs_check_parts );
  430.   }
  431.  
  432.  
  433.   /**
  434.    *
  435.    */
  436.   define boolean OSRPartitionFSCheck()``{
  437.  
  438.       /////////////////////////////////////////////////////////
  439.       //
  440.       // fsck for all possible partitions
  441.       //
  442.       /////////////////////////////////////////////////////////
  443.       list<map> fsck_partitions        = (list<map>)
  444.     OSRCommon::RequireList("fsck_partitions");
  445.       list<map> mounted_partitions    = (list<map>)
  446.     OSRCommon::RequireList("mounted_partitions");
  447.       list<string> checked_partitions = [];
  448.  
  449.       foreach(map p, fsck_partitions, ``{
  450.  
  451.       string  dev_name   = p["device"]:"";
  452.       // summary header
  453.       string summary_header  = sformat(_("Executing file system check for partition %1..."),  dev_name  );
  454.  
  455.       if( size( filter(map p, mounted_partitions, ``(p["spec"]:""  == dev_name ))) != 0 )
  456.       {
  457.         // summary text
  458.         OSRSummary::DetectOK(summary_header, _("Partition mounted: check impossible"));
  459.         checked_partitions = add(checked_partitions, dev_name );
  460.       }
  461.       else
  462.       {
  463.           boolean fs_ok    = OSRFsck::Check( p );
  464.           symbol used_fs  = Storage::GetPartition( Storage::GetTargetMap(),
  465.                                                p["device"]:"" )["detected_fs"]:`none;
  466.           if ( fs_ok == true )
  467.           {
  468.             OSRSummary::DetectOK(summary_header,
  469.                 // summary text, %1 is device, %2 file system type
  470.                 sformat(_("%1 contains valid %2 file system"),
  471.                     dev_name, FileSystems::GetName( used_fs, "unknown") ));
  472.             checked_partitions = add(checked_partitions, dev_name );
  473.           }
  474.           else
  475.           {
  476.         string fsname = FileSystems::GetName( used_fs, "unknown");
  477.             // summary text, %1 is device, %2 file system type
  478.         string summary = sformat (_("%1 contains no valid %2 file system"),
  479.                 dev_name, fsname );
  480.         if (fsname == "unknown")
  481.         // summary text, %1 is device
  482.         summary = sformat(_("%1 contains unknown file system"),dev_name);
  483.  
  484.             OSRSummary::DetectError (summary_header, summary);
  485.             if( fs_ok != nil )
  486.             {
  487.               symbol ret = OSRFsck::Repair(dev_name, used_fs );
  488.               // start repairing !!x
  489.               OSRSummary::SetRepairSummary( ret ,
  490.                            summary_header,
  491.                            // summary text
  492.                            _("Repair was successful"),
  493.                            // summary text
  494.                            _("Repair was skipped"),
  495.                            // summary text
  496.                            _("Repair was not successful"));
  497.               if ( ret == `ok )
  498.               {
  499.                 checked_partitions = add(checked_partitions, dev_name );
  500.               }
  501.             }
  502.           }
  503.       }
  504.       });
  505.       OSRCommon::ProvideList( "checked_partitions", checked_partitions );
  506.       return true;
  507.   }
  508.  
  509.     /**
  510.      * //////////////////////////////////////////////////
  511.      * // search for valid Linux partitions
  512.      * //////////////////////////////////////////////////
  513.      */
  514.     define boolean OSRPartitionLinuxPartitions()``{
  515.  
  516.       // Raid and LVM not supported at the moment!!
  517.       list<string> checked_partitions    = (list<string>)
  518.     OSRCommon::RequireList("checked_partitions");
  519.       list<string> linux_partition_list =
  520.     OSRFstab::LinuxPartitions(checked_partitions);
  521.  
  522.       if (size(linux_partition_list) <= 0 )
  523.       {
  524.         // summary text
  525.         OSRSummary::DetectError("", _("No valid partition types were found"));
  526.         // popup label
  527.         if( Popup::AnyQuestion(_("No Valid Linux Partitions Found"),
  528.             // popup text
  529.             _("Could not detect any valid Linux partitions
  530. in your system. There probably is no valid
  531. Linux system on this computer. If you are
  532. sure that you installed a Linux system,
  533. press Retry Scanning. Otherwise
  534. skip scanning the system and start a new
  535. installation.
  536. "),
  537.             // button label
  538.             _("&Retry Scanning"),
  539.             Label::CancelButton(),
  540.             `focus_yes) )
  541.         {
  542.             OSRStatus::RestartScan("find_harddisks");
  543.             return true;
  544.         }
  545.         else
  546.         {
  547.             OSRStatus::ErrorSeverityBlocking();
  548.             if (Stage::initial ())
  549.             {
  550.                 OSR::SetReboot();
  551.                 y2milestone ( "Make a hard reboot" );
  552.             }
  553.             return false;
  554.         }
  555.       }
  556.       else
  557.       {
  558.         OSRSummary::DetectOK("",
  559.             // summary text
  560.             sformat(_("Valid Linux partitions were found:<br>%1"),
  561.                 mergestring(linux_partition_list, ", ")));
  562.       }
  563.       OSRCommon::ProvideList("linux_partition_list", linux_partition_list);
  564.       return true;
  565.   }
  566.  
  567.  
  568.   /**
  569.    *
  570.    */
  571.   define boolean OSRPartitionMountableLinuxPartitions()``{
  572.  
  573.       /////////////////////////////////////////////////////////
  574.       //
  575.       // search for mountable partitions
  576.       //
  577.       /////////////////////////////////////////////////////////
  578.       list<string> linux_partition_list    = (list<string>)
  579.     OSRCommon::RequireList("linux_partition_list");
  580.       list<string> mount_possible_list  = OSRFstab::MountablePartitions(linux_partition_list, OSRSystem::TargetRoot());
  581.  
  582.       if ( size(mount_possible_list) > 0 )
  583.       {
  584.         OSRSummary::DetectOK("",
  585.             // summary text
  586.             sformat(_("Mountable partitions were found:<br>%1"),
  587.                 mergestring(mount_possible_list, ", ")));
  588.  
  589.         OSRCommon::ProvideList("mount_possible_list", mount_possible_list);
  590.         return true;
  591.       }
  592.       else
  593.       {
  594.         // summary text
  595.         OSRSummary::DetectError("", _("No mountable partitions were found"));
  596.         // popup label
  597.         if( Popup::AnyQuestion(_("No Mountable Partitions Found"),
  598.             // popup text
  599.             _("
  600. Could not detect any mountable partitions
  601. in your system. Probably there is no valid
  602. Linux system on this computer. If you are sure
  603. that you installed a Linux system, press 
  604. Retry Scanning. Otherwise skip scanning
  605. the system and start a new installation.
  606. "),
  607.             // button label
  608.             _("&Retry Scanning"),
  609.             Label::CancelButton(),
  610.             `focus_yes ) )
  611.         {
  612.             OSRStatus::RestartScan("find_harddisks");
  613.             return true;
  614.         }
  615.         else
  616.         {
  617.             OSRStatus::ErrorSeverityBlocking();
  618.             if (Stage::initial ())
  619.             {
  620.                 OSR::SetReboot();
  621.                 y2milestone ( "Make a hard reboot" );
  622.             }
  623.             return false;
  624.         }
  625.       }
  626.  
  627.       list<string> not_mountable_linux  = filter(string p, linux_partition_list, ``( ! contains( mount_possible_list, p)));
  628.       if ( size( not_mountable_linux ) != 0 ) {
  629.  
  630.       // summary text
  631.       OSRSummary::DetectProblem(_("Unmountable Linux partitions"),
  632.         mergestring(not_mountable_linux, " " ));
  633.       }
  634.  
  635.       return true;
  636.   }
  637.  
  638.  
  639.   /**
  640.    *  Checks the detected partitions for valid filesystems, mounts them and
  641.    *  searches for filesystem tables (/etc/fstab) on the partitions.
  642.    *
  643.    *  @return map The result_map.
  644.    */
  645.   define boolean OSRPartitionFindRootPartitions() ``{
  646.  
  647.       /////////////////////////////////////////////////////////////////
  648.       //
  649.       // search for valid root partitions with a filesystem table
  650.       //
  651.       /////////////////////////////////////////////////////////////////
  652.  
  653.       list<map> valid_root_partition_list = OSRFstab::ValidRootPartitions (
  654.         (list<string>) OSRCommon::RequireList("mount_possible_list"),
  655.     OSRSystem::TargetRoot());
  656.       string  root_partition         = "";
  657.  
  658.       if (size(valid_root_partition_list) == 1)
  659.       {
  660.         root_partition = valid_root_partition_list[0,"device"]:"";
  661.         // summary text (%1 is root partition)
  662.         OSRSummary::DetectOK("", sformat(_("One valid partition was found: %1"),
  663.             root_partition));
  664.       }
  665.       else if ( size(valid_root_partition_list) > 1 )
  666.       {
  667.     string partitions_string    = mergestring (
  668.         maplist (map part, valid_root_partition_list,``(part["device"]:"")),
  669.         ", "
  670.     );
  671.         // several valid root partitions found
  672.         OSRSummary::DetectOK ("",
  673.             // summary text (%1 are root partitions)
  674.             sformat (_("Several valid root partitions were found:<br>%1"),
  675.         partitions_string)
  676.     );
  677.  
  678.       if( ! Stage::initial () )
  679.       {
  680.           // choose root partitions only if booted from cd.
  681.           // problem with SCR agent. and /mnt (root_mountpoint)
  682.           map root_map = Storage::GetEntryForMountpoint("/");
  683.           root_partition = root_map["device"]:"";
  684.       }
  685.       if( Stage::initial () || root_partition == "" )
  686.       {
  687.           // launch a popup with a RadioButtonGroup
  688.           // - one button for each item in the list -
  689.           // and let the user select the root partition
  690.           root_partition = OSRFstab::SelectRoot (valid_root_partition_list);
  691.       }
  692.       }
  693.  
  694.       if (size(valid_root_partition_list) <= 0  || root_partition == "" )
  695.       {
  696.         // summary text
  697.         OSRSummary::DetectError("", _("No valid root partition was found"));
  698.         // popup label
  699.         if( Popup::AnyQuestion(_("No Valid Root Partition Found"),
  700.             // popup text
  701.             _("
  702. Could not detect any valid root partition
  703. in your system. Probably there is no valid
  704. Linux system on this computer. If you are
  705. sure that you installed a Linux system, try 
  706. to restart scanning. Otherwise skip scanning and
  707. start a new installation.
  708. "),
  709.             // button label
  710.             _("&Retry Scanning"),
  711.             Label::CancelButton(),
  712.             `focus_yes ) )
  713.         {
  714.           OSRStatus::RestartScan("find_harddisks");
  715.           return true;
  716.         }
  717.         else {
  718.          OSRStatus::ErrorSeverityBlocking();
  719.          if (Stage::initial ())
  720.          {
  721.          OSR::SetReboot();
  722.          y2milestone ( "Make a hard reboot" );
  723.          }
  724.          return false;
  725.      }
  726.       }
  727.  
  728.       OSRCommon::ProvideString("root_partition", root_partition);
  729.       OSRCommon::ProvideList("valid_root_partitions", valid_root_partition_list );
  730.       return true;
  731.   };
  732.  
  733.  
  734.  
  735.   define boolean OSRPartitionMountRoot()``{
  736.  
  737.     /////////////////////////////////////////////////////////////////////////
  738.     //
  739.     //  mount the root partition to /mnt
  740.     //
  741.     /////////////////////////////////////////////////////////////////////////
  742.     string root_partition    = OSRCommon::RequireString ("root_partition");
  743.  
  744.     list<map> just_mounted    = [];
  745.  
  746.     // summary header, %1 is root partition, %2 target
  747.     string  summary_header    = sformat(_("Mounting root partition %1 to %2..."),
  748.     root_partition, OSRSystem::TargetRoot());
  749.  
  750.     // check if the specified partition is already mounted to "/mnt",
  751.     // mount only if it is not already done.
  752.     if ( OSRSystem::TargetRoot() != Storage::DeviceMounted (root_partition))
  753.     {
  754.     // Mount selected partition to /mnt
  755.         if ((boolean) WFM::Execute (.local.mount,
  756.         [root_partition, OSRSystem::TargetRoot(),OSRExecute::OutputFile()]))
  757.         {
  758.         // add the mounted partition to the list, this has to be known for
  759.         // being able to umount all partitions that were mounted
  760.         // by the rescue system
  761.         just_mounted = add (just_mounted, $[
  762.         "partition"    : root_partition,
  763.         "mountpoint"    : OSRSystem::TargetRoot()
  764.         ]);
  765.         OSRSummary::DetectOK (summary_header,
  766.         // summary text
  767.         _("Root partition was successfully mounted"));
  768.     }
  769.     else
  770.     {
  771.         OSRSummary::DetectError (summary_header,
  772.         // summary text, %1 is mount point
  773.         sformat(_("Root partition was not successfully mounted to %1"),
  774.             OSRSystem::TargetRoot() ));
  775.  
  776.         if (size (OSRCommon::RequireList("valid_root_partitions")) > 1)
  777.         {
  778.  
  779.         if (Popup::AnyQuestion (sformat (
  780.             // popup label, %1 is mount point
  781.             _("Could Not Mount Root Partition to %1"),
  782.             OSRSystem::TargetRoot()),
  783.             // popup text, %1 is root partition
  784.             sformat (_("
  785. Unable to mount the root partition %1.
  786. Restart the scanning and choose a another
  787. root partition or cancel scanning the system.
  788. "), root_partition),
  789.             // button label
  790.             _("&Restart Scanning"), Label::CancelButton(), `focus_yes)
  791.         )
  792.         {
  793.             OSRStatus::RestartScan ("find_valid_root_partitions");
  794.             return true;
  795.         }
  796.         }
  797.         OSRStatus::ErrorSeverityModuleBlocking();
  798.         return false;
  799.     }
  800.     }
  801.     else
  802.     {
  803.     OSRSummary::DetectOK(
  804.         // summary header (%1 is partition, %2 mount point)
  805.             sformat(_("Mounting root partition %1 to %2..."),
  806.                 root_partition, OSRSystem::TargetRoot()),
  807.             // summary text (%1 is mount point)
  808.             sformat(_("Root partition is already mounted to %1"),
  809.                 OSRSystem::TargetRoot()  ));
  810.     }
  811.  
  812.     OSRCommon::ProvideList("just_mounted", just_mounted );
  813.     OSRCommon::ProvideBoolean("root_mounted", true );
  814.     return true;
  815.   }
  816.  
  817.   /**
  818.    *  Mount the root partition and all reachable, local and valid partitions
  819.    *  from the detected filesystem table "/etc/fstab".
  820.    *
  821.    *  Requires: list valid_root_partitions,
  822.    *            string root_partition
  823.    *  Provides: list just_mounted,
  824.    *            string root_mountpoint
  825.    *
  826.    *  @return map The result_map.
  827.    */
  828.   define boolean OSRPartitionReadFstab() ``{
  829.  
  830.       /////////////////////////////////////////////////////////////////////////
  831.       //
  832.       //  get the fstab
  833.       //
  834.       /////////////////////////////////////////////////////////////////////////
  835.  
  836.       // summary header
  837.       string summary_header   = sformat(_("Reading fstab of root partition %1..."),  OSRCommon::RequireString("root_partition"));
  838.  
  839.       if ( ! OSRFstab::ReadFstab(OSRSystem::TargetRoot(), false))
  840.       {
  841.         // summary text
  842.         OSRSummary::DetectError( summary_header, _("fstab could not be read"));
  843.  
  844.         if( size( OSRCommon::RequireList("valid_root_partitions")) > 1 ) {
  845.             // popup label, fstab is filename
  846.             if( Popup::AnyQuestion(_("Could Not Read fstab"),
  847.                 // popup text
  848.                 _("
  849. Unable to read fstab.
  850. Restart the scan and choose another
  851. root partition or cancel scanning the system.
  852. "),
  853.                 // button label
  854.                 _("&Restart Scanning"),
  855.                 Label::CancelButton(),
  856.                 `focus_yes ))
  857.           {
  858.               OSRStatus::RestartScan("find_valid_root_partitions");
  859.               return true;
  860.           }
  861.       }
  862.       OSRStatus::ErrorSeverityModuleBlocking();
  863.       return false;
  864.       }
  865.       else
  866.       {
  867.         // summary text
  868.         OSRSummary::DetectOK( summary_header, _("fstab read"));
  869.       }
  870.  
  871.       OSRCommon::ProvideBoolean("fstab_readed", true);
  872.       return true;
  873.   }
  874.  
  875.  
  876.   /**
  877.    * Check the root entry in the fstab.
  878.    */
  879.   define boolean OSRPartitionCheckFstabRoot()``{
  880.  
  881.       if (OSRFstab::CheckRootEntry (OSRCommon::RequireString("root_partition"),
  882.         (list<string>) OSRCommon::RequireList("swapable_partitions"),
  883.             (list<string>) OSRCommon::RequireList("checked_partitions")) ||
  884.       Mode::test ())
  885.       {
  886.         // summary text
  887.         OSRSummary::DetectOK("", _("The root entry of fstab is valid"));
  888.       }
  889.       else {
  890.  
  891.         // summary text
  892.         OSRSummary::DetectError("", _("The root entry of fstab is not valid"));
  893.  
  894.         OSRSummary::SetRepairSummary(OSRFstab::Repair(),
  895.                        "",
  896.                        // summary text
  897.                        _("Repairing the root entry was successful"),
  898.                        // summary text
  899.                        _("Repair was skipped"),
  900.                        // summary text
  901.                        _("Repair was not successful"));
  902.       }
  903.       OSRCommon::ProvideBoolean("fstab_root_checked",true);
  904.       return true;
  905.   }
  906.  
  907.   /**
  908.    * Check all entris (without root) in the fstab.
  909.    */
  910.   define boolean OSRPartitionCheckFstab()``{
  911.  
  912.       string root_partition    = OSRCommon::RequireString("root_partition");
  913.  
  914.       if ( OSRFstab::Check (
  915.         (list<string>)OSRCommon::RequireList("swapable_partitions"),
  916.         (list<string>)OSRCommon::RequireList("checked_partitions")))
  917.       {
  918.         // summary text
  919.         OSRSummary::DetectOK("", _("fstab entries valid"));
  920.       }
  921.       else
  922.       {
  923.         // summary text
  924.         OSRSummary::DetectError("",_("At least one fstab entry is not valid"));
  925.  
  926.         OSRSummary::SetRepairSummary(OSRFstab::Repair(),
  927.                        "",
  928.                        // summary text
  929.                        _("The fstab entry was successfully repaired"),
  930.                        // summary text
  931.                        _("Repair was skipped"),
  932.                        // summary text
  933.                        _("Repair was not successful"));
  934.       }
  935.       OSRCommon::ProvideBoolean( "fstab_checked", true);
  936.       return true;
  937.   };
  938.  
  939.  
  940.   /**
  941.    * Reset temporary settings.
  942.    */
  943.   define boolean OSRPartitionReset()``{
  944.  
  945.       // umount just_mount!!
  946.       list<map> just_mounted    = (list<map>) OSRCommon::RequireList("just_mounted");
  947.       just_mounted      = sort(map x, map y, just_mounted,
  948.         ``(size(splitstring(x["mountpoint"]:"", "/")) >
  949.            size(splitstring( y["mountpoint"]:"" ,"/"))));
  950.       y2milestone(" just_mounted %1", just_mounted );
  951.  
  952.       // mount just_umounted!!
  953.       list<map> just_umounted   = (list<map>) OSRCommon::RequireList("just_umounted");
  954.       just_umounted        = sort(map x, map y, just_umounted,
  955.         ``(size(splitstring(x["mountpoint"]:"", "/")) <
  956.            size(splitstring(y["mountpoint"]:"" ,"/"))));
  957.  
  958.       just_mounted = (list<map>) union ( [
  959.             $[  "partition" : "usbfs",
  960.                 "mountpoint" : OSRSystem::TargetRoot() + "/proc/bus/usb" ],
  961.             $[  "partition" : "proc",
  962.                 "mountpoint" : OSRSystem::TargetRoot() + "/proc" ]
  963.             ], just_mounted );
  964.  
  965.       // build todo map
  966.       list<map> todo = [];
  967.  
  968.       foreach(map mp, just_mounted, ``{
  969.         todo = add( todo, add( mp, "path", .local.umount ));
  970.       });
  971.       foreach(map mp, just_umounted, ``{
  972.         todo = add( todo, add( mp, "path", .local.mount ));
  973.       });
  974.  
  975.       y2milestone(" reset map %1" , todo);
  976.       // execute todo
  977.       foreach( map mp , todo , ``{
  978.       if( (mp["path"]:.local.umount == .local.mount )
  979.       ? (boolean) WFM::Execute(mp["path"]:.local.mount,
  980.         [ mp["partition"]:"", mp["mountpoint"]:""])
  981.           : (boolean) WFM::Execute(mp["path"]:.local.umount,
  982.         mp["mountpoint"]:"" ))
  983.       {
  984.           y2milestone(" %1 %2 succeeded", mp["path"]:.local.umount,mp["mountpoint"]:"" );
  985.       }
  986.       else {
  987.           y2error(" %1 %2 failed",  mp["path"]:.local.umount,mp["mountpoint"]:"" );
  988.       }
  989.       });
  990.  
  991.       OSRModuleLoading::UnloadAll();
  992.  
  993.       OSRPtbl::Reset();
  994.       OSRFsck::Reset();
  995.       OSRFstab::Reset();
  996.  
  997.       return true;
  998.   }
  999.  
  1000.   /**
  1001.    * Direct partitioning with the custom part tool.
  1002.    */
  1003.   define symbol OSRDirectCustomPart()``{
  1004.  
  1005.       y2milestone("Direct start Custom Part");
  1006.  
  1007.       // remove all mount points
  1008.       map<string,map> target_map = Storage::GetTargetMap();
  1009.       foreach(string dev, map parts, (map<string,map>) target_map, ``{
  1010.     integer counter = 0;
  1011.     foreach (map part, parts["partitions"]:[], ``{
  1012.         if ( part["mount"]:"" != "" )
  1013.         target_map[dev, "partitions", counter,"mount"] = "";
  1014.         counter = counter  +1;
  1015.     });
  1016.       });
  1017.       Storage::SetTargetMap(target_map);
  1018.       Storage::SetPartMode("CUSTOM");
  1019.       Storage::SetPartProposalActive(false);
  1020.  
  1021.       symbol ret = `next ;
  1022.       UI::NormalCursor();
  1023.       repeat {
  1024.  
  1025.       ret = (symbol) WFM::CallFunction ("inst_disk", [true, true] );
  1026.  
  1027.       if ( ret == `next  )
  1028.       {
  1029.       // TODO: ReallyInstPrepdisk should be part of some module...
  1030.       // (now included from "partitioning/custom_part_dialogs.ycp")
  1031.           ret = ReallyInstPrepdisk ();
  1032.           if ( ret == `back ) ret = `again;
  1033.  
  1034.           if ( ret == `apply  )
  1035.           {
  1036.         ret = (symbol) WFM::CallFunction ("inst_prepdisk", [false, false]);
  1037.         ret = `again;
  1038.           }
  1039.           if ( ret == `finish )
  1040.           {
  1041.         ret = (symbol) WFM::CallFunction ("inst_prepdisk", [false, false]);
  1042.           }
  1043.       }
  1044.       } until ( ret ==  `back || ret == `next || ret == `ok || ret == `cancel || ret == `abort);
  1045.       return ret;
  1046.   }
  1047.  
  1048.   /**
  1049.    * Direct recover a lost partition table.
  1050.    */
  1051.   define symbol OSRDirectPartitionTable()``{
  1052.  
  1053.       y2milestone("Direct start repairing partition table");
  1054.  
  1055.       symbol ret             = `next;
  1056.       map<string,map> tg = filter( string k, map d, Storage::GetTargetMap(), 
  1057.                                    ``(Storage::IsRealDisk(d)));
  1058.       list<string> disk_list = maplist( string k, map d, tg, ``(k));
  1059.       string repair_dev      = disk_list[0]:"";
  1060.  
  1061.       UI::NormalCursor();
  1062.       // select the root partition
  1063.       if( size( disk_list ) > 1)
  1064.       {
  1065.         // RadioButtonGroup label
  1066.         repair_dev =  OSRPopup::RadioButtonGroup(_("Hard Disk"),
  1067.             // RadioButtonGroup text
  1068.             _("
  1069. There are several hard disk in your system.
  1070. Select the hard disk for which YaST
  1071. should try to recover lost partitions.
  1072. "),
  1073.             disk_list,
  1074.             "cancel",
  1075.             true
  1076.             );
  1077.       }
  1078.       else if( repair_dev == "" )
  1079.       {
  1080.         // error popup
  1081.         Report::Error("
  1082. YaST can not found any valid hard
  1083. disk at your system. Recovering a
  1084. lost partitions is not possible.
  1085. ");
  1086.         ret = `error;
  1087.       }
  1088.  
  1089.       if( repair_dev != "cancel" && repair_dev != "" )
  1090.       {
  1091.         OSRPtbl::SetTarget( repair_dev );
  1092.  
  1093.         ret = OSRPtbl::RestoreWithGpart ();
  1094.       }
  1095.  
  1096.       OSRPtbl::Reset();
  1097.       return ret;
  1098.   }
  1099.  
  1100.  
  1101.   /**
  1102.    * Direct repair a damaged file system.
  1103.    */
  1104.   define symbol OSRDirectFilesystem()``{
  1105.  
  1106.       y2milestone("Direct start repairing a file system ");
  1107.  
  1108.       list<map> parts_data = [];
  1109.       foreach( string k, map disk, Storage::GetTargetMap(),
  1110.            ``{parts_data = (list<map>)union( parts_data, 
  1111.                                              disk["partitions"]:[]);});
  1112.  
  1113.       parts_data = filter(map p, parts_data,
  1114.         ``(  ( contains ( OSRFsck::fsck_fsid, p["fsid"]:0 )) &&
  1115.                contains ( OSRFsck::fsck_type, p["type"]:`unknown )));
  1116.  
  1117.       list<string> partitions = maplist(map p, parts_data, ``(p["device"]:""));
  1118.       string scan_dev         = "";
  1119.  
  1120.       UI::NormalCursor();
  1121.       if( size(partitions) == 0  )
  1122.       {
  1123.         // error popup
  1124.         Report::Error("
  1125. YaST can not found any valid partitions
  1126. at your system. Executing a file system
  1127. check is not possible.");
  1128.         return `error;
  1129.       }
  1130.       else if( size( partitions ) > 0 )
  1131.       {
  1132.         // RadioButtonGroup label
  1133.         scan_dev =  OSRPopup::RadioButtonGroup(_("Partition"),
  1134.             // RadioButtonGroup text
  1135.             _("
  1136. Select the partition on which to execute a file system check.
  1137. "),
  1138.             partitions,
  1139.             partitions[0]:"",
  1140.             false
  1141.             );
  1142.       }
  1143.       if( scan_dev != "" )
  1144.       {
  1145.       import "OSRLogFile";
  1146.  
  1147.       map p = Storage::GetPartition( Storage::GetTargetMap(), scan_dev );
  1148.  
  1149.       if( p["mount"]:"" != "" )
  1150.       {
  1151.           if( contains( OSRFstab::system_mount_points,  p["mount"]:""))
  1152.           {
  1153.             // error popup. %1 is partition, %2 is mount point
  1154.             Report::Error( sformat(_("
  1155. The selected partition %1 is
  1156. currently mounted on the system mount point %2.
  1157. This partition cannot be unmounted here.
  1158. Start the YaST rescue tool from CD-ROM and
  1159. try executing the file system check again.
  1160. "), scan_dev, p["mount"]:""));
  1161.             return `error;
  1162.  
  1163.           }
  1164.           else
  1165.           {
  1166.             // popup label
  1167.             if (! Popup::YesNoHeadline(_("Partition Mounted"),
  1168.                 // popup text
  1169.                 sformat(_("
  1170. The selected partition %1 is 
  1171. currently mounted. 
  1172. Unmount the partition then execute
  1173. a file system check?
  1174. "), scan_dev )))
  1175.           {
  1176.               return `error;
  1177.           }
  1178.           else {
  1179.               WFM::Execute(.local.umount,  p["mount"]:""   );
  1180.  
  1181.               if( Storage::DeviceMounted( scan_dev ) != "" )
  1182.               {
  1183.                 // error popup
  1184.                 Report::Error(sformat(_("
  1185. Unmounting the partition %1 is
  1186. not possible. A file system check
  1187. cannot be executed.
  1188. "), scan_dev ));
  1189.                 return `error;
  1190.               }
  1191.           }
  1192.           }
  1193.       }
  1194.  
  1195.       symbol ret = `next;
  1196.       string direct_name = OSRCommon::current_direct_name;
  1197.  
  1198.       term progress = OSRProgress::Create(`fsck_progress,
  1199.                           _("Progress"),
  1200.                           0,true);
  1201.       term contents = `HBox(
  1202.     `HSpacing(1),
  1203.         `VBox(
  1204.             `VSpacing(1),
  1205.         // label
  1206.             `HBox(`HWeight(30,`Left(`Heading(_("Checking file system...")))),
  1207.             `HWeight(30, `HSpacing(10))),
  1208.             `VSpacing(1),
  1209.         // partition is appended
  1210.             `Left(`Label(_("Partition: ") + scan_dev )),
  1211.             `VSpacing(1),
  1212.             progress,
  1213.             `VSpacing(1)
  1214.         ),
  1215.     `HSpacing(1)
  1216.       );
  1217.       UI::OpenDialog( contents );
  1218.  
  1219.       OSRProgress::DeleteFile( OSRLogFile::GetTmpDir() + "/"+ direct_name );
  1220.       OSRProgress::SetFile(`fsck_progress, OSRLogFile::GetTmpDir() + "/"+ direct_name );
  1221.       boolean fs_ok     = OSRFsck::Check( p );
  1222.       OSRProgress::Fill(`fsck_progress);
  1223.       UI::CloseDialog();
  1224.  
  1225.       if( fs_ok == nil )
  1226.       {
  1227.           // error popup
  1228.           Report::Error(sformat(_("
  1229. Cannot detect the file system type
  1230. of the partition %1. Executing a file
  1231. system check is not possible.
  1232. "), scan_dev ));
  1233.           ret = `error;
  1234.       }
  1235.       else
  1236.       {
  1237.           symbol used_fs = p["detected_fs"]:`none;
  1238.           if (fs_ok)
  1239.       {
  1240.         if (OSRFsck::IsNonLinuxFileSystem (used_fs))
  1241.         // message popup %1 is partition, %2 filesystem type name
  1242.         Report::Message(sformat(_("
  1243. The partition %1 contains
  1244. the non-Linux file system %2.
  1245. No partitions checks were done.
  1246. "),scan_dev, FileSystems::GetName( used_fs, "unknown") ));
  1247.         else
  1248.         // message popup %1 is partition, %2 filesystem type name
  1249.         Report::Message(sformat(_("
  1250. The partition %1 contains
  1251. a valid %2 file system.
  1252. "),scan_dev, FileSystems::GetName( used_fs, "unknown") ));
  1253.           }
  1254.           else
  1255.       {
  1256.         if( OSRFsck::Repair(scan_dev, used_fs ) != `ok )
  1257.         {
  1258.         ret =  `error;
  1259.         }
  1260.           }
  1261.       }
  1262.       OSRFsck::Reset();
  1263.       return ret;
  1264.       }
  1265.       return `cancel;
  1266.   }
  1267.  
  1268.   /**
  1269.    * Save disk partition info to floppy
  1270.    */
  1271.   define symbol OSRDirectSave2Floppy()``{
  1272.  
  1273.       import "OSRFloppy";
  1274.       import "StorageDevices";
  1275.  
  1276.  
  1277.       UI::NormalCursor();
  1278.       if (!StorageDevices::FloppyPresent)
  1279.       {
  1280.     // message popup (no floppy drive was detected)
  1281.     Report::Message(_("
  1282. No floppy drive detected in your
  1283. system. Saving system information is not
  1284. possible.
  1285. "));
  1286.     return `error;
  1287.       }
  1288.       // popup text
  1289.       if (! Popup::ContinueCancel(_("
  1290. Insert a formatted disk
  1291. in your floppy drive and press
  1292. Continue.
  1293. ")))
  1294.       {
  1295.     return `cancel;
  1296.       }
  1297.  
  1298.       map target_map = Storage::GetTargetMap();
  1299.       boolean error  = false;
  1300.  
  1301.       if (OSRFloppy::Open (true, size(target_map)))
  1302.       {
  1303.           foreach (string key, map v, (map<string,map>) target_map, {
  1304.         if (v["type"]:`CT_UNKNOWN != `CT_DISK)
  1305.         return;
  1306.         OSRFloppy::NextStep (
  1307.         // progress label
  1308.         sformat (_("Saving partition table of disk %1..."), key));
  1309.         if (!error &&
  1310.         !OSRPtbl::WritePartitionsInfo2Floppy (key, v["partitions"]:[]))
  1311.         {
  1312.               // eroro popup
  1313.               Report::Error(sformat(_("
  1314. The primary partition table of disk %1
  1315. was not written correctly to floppy disk.
  1316. "), key));
  1317.                 error = true;
  1318.         }
  1319.           });
  1320.       }
  1321.       OSRFloppy::Close();
  1322.  
  1323.       if ( error )
  1324.       {
  1325.           // eroro popup
  1326.           Report::Error(_("
  1327. Writing the system information was
  1328. not successful. Try again.
  1329. "));
  1330.           return `error;
  1331.       }
  1332.       else {
  1333.           // message popup
  1334.           Report::Message(_("Writing the system information was successful.
  1335. "));
  1336.  
  1337.       }
  1338.       return `ok;
  1339.   }
  1340.  
  1341.   //////////////////////////////////////////////////////////////////////
  1342.   //
  1343.   //  METHODS
  1344.   //
  1345.   //////////////////////////////////////////////////////////////////////
  1346.  
  1347.   /**
  1348.    *  Initialization of the module map that contains all important information
  1349.    *  for this module.
  1350.    *
  1351.    *  @return map The map that contains all information about the module
  1352.    *  osr_module_partition.
  1353.    */
  1354.  
  1355.   define map OSRPartitionInit() ``{
  1356.       return $[
  1357.            // has to be the name of the file
  1358.            "name"              :  "osr_module_partition",
  1359.                                   // module headline
  1360.            "headline"          :  _("Partitions and File Systems"),
  1361.            "global_entries"    : $[
  1362.                        "mbr_check" : $[
  1363.                                       // module action label
  1364.                           "text"    : _("Check Partition Tables"),
  1365.                                       // helptext
  1366.                           "help"    : _("
  1367. <P>
  1368. The partition table is the part of
  1369. a hard disk where the information about
  1370. the size and the position of the
  1371. partitions of a hard disk are stored.
  1372. Every hard disk has its own partition
  1373. table.</P>
  1374. ") +
  1375. _("<P>Without such a partition table,
  1376. Linux cannot find a partition on a hard
  1377. disk.</P>
  1378. ") +
  1379.  
  1380. _("<P>
  1381. If you delete a partition by mistake,
  1382. it is sometimes possible to recover the
  1383. lost partition. This tool can analyze
  1384. the hard disk and try to find such a
  1385. partition.
  1386. The partition table can also be lost 
  1387. or damaged due to a system crash or a virus.
  1388. Even in these cases, it can sometimes
  1389. recover a partition table.</P>
  1390. ")
  1391.                        ],
  1392.                        "swap_check" :
  1393.                        $[
  1394.                                   // module action label
  1395.                          "text" : _("Check Swap Areas"),
  1396.                                   // helptext
  1397.                          "help" : _("
  1398. <P>
  1399. The swap area is the virtual memory of a
  1400. Linux system. Linux swap areas can be a
  1401. special partition or a file.</P>
  1402. ") +
  1403.  
  1404. _("<P>
  1405. This procedure checks all swap areas found.
  1406. If a swap area is damaged, the system can create
  1407. a new swap area.
  1408. </P>
  1409. ")
  1410.                        ],
  1411.                        "fs_check" :
  1412.                        $[
  1413.                                   // module action label
  1414.                          "text" : _("Check File Systems"),
  1415.                                   // helptext
  1416.                          "help" : _("
  1417. <P>
  1418. Formatting a partition means a
  1419. file system will be created in a partition.
  1420. After that, you can mount the partition and
  1421. save files and other data to the partition.
  1422. Linux can normally only use partitions with
  1423. a valid file system for saving data and
  1424. programs. </p>
  1425. ") +
  1426.  
  1427. _("<P>
  1428. An inconsistent file system occurs when
  1429. a partition is not correctly unmounted.
  1430. For example, this happens when the system
  1431. crashes.</p>
  1432. ") +
  1433.  
  1434. _("<p>There is a repair method for each file
  1435. system. For example, if the file system
  1436. of the damaged partition is ext2 or
  1437. ext3, use fsck.ext2 (e2fsck) with the
  1438. corresponding options to repair the
  1439. file system.</P>
  1440. ") +
  1441. _("<P>This procedure checks the file system of all
  1442. partitions found and suggests 
  1443. repairing it if an error was found.</P>
  1444. ")
  1445.                          ],
  1446.  
  1447.                        "fstab_check" :
  1448.                        $[
  1449.                                   // module action label
  1450.                          "text" : _("Check fstab Entries"),
  1451.                                   // helptext
  1452.                          "help" : _("
  1453. <P>
  1454. fstab is a configuration file that
  1455. contains entries for all devices that should
  1456. be mounted during the boot process. 
  1457. If you have deleted a partiton without
  1458. removing the corresponding fstab entry, you
  1459. get a warning during the boot process.</P>
  1460. ")+
  1461.  
  1462. _("<P>
  1463. This procedure checks all entries listed in 
  1464. fstab and reports missing, obsolete, and
  1465. erroneous entries.</P>
  1466. "),
  1467.                          "requires" : ["fs_check", "swap_check"]
  1468.                        ]
  1469.            ],
  1470.  
  1471.            "static_provides"    : $[
  1472.                         //"root_mountpoint"     : "/mnt"
  1473.  
  1474.            ],
  1475.            "reset_methods"      : [
  1476.                                       // module reset label
  1477.                        $["summary"  : _("Reset Module Settings"),
  1478.                          "method"   : OSRPartitionReset,
  1479.                          "provides" : 10 ]
  1480.            ],
  1481.            // the sequence of the detection methods of this module
  1482.            "detect_methods"    :  [
  1483.                        $[ "name"      : "find_harddisks",
  1484.                                         // module method progress label
  1485.                            "summary"  : _("Searching for hard disks..."),
  1486.                            "method"   : OSRPartitionCheckDiskCount,
  1487.                            "requires" :  ["repair_target"],
  1488.                            "provides" :  ["valid_target"],
  1489.                            "group"    : "mbr_check",
  1490.                            "progress" : 10
  1491.                           ],
  1492.                        $[ "name"     : "check_harddisks",
  1493.                                         // module method progress label
  1494.                           "summary"  : _("Checking partition tables..."),
  1495.                           "method"   : OSRPartitionCheckDisks,
  1496.                           "requires" :  [ "has_floppy", "valid_target"],
  1497.                           "provides" :  [ "valid_target_list"],
  1498.                           "group"    : "mbr_check",
  1499.                           "progress" :  100
  1500.                           ],
  1501.                        $["name"   : "find_swap",
  1502.                                         // module method progress label
  1503.                           "summary"   : _("Searching for valid swap partitions..."),
  1504.                           "method"    : OSRPartitionCheckSwap,
  1505.                            "requires" :  [ "valid_target_list"   ],
  1506.                           "provides"  :  [ "swap_partition_list" ],
  1507.                          "group"      : "swap_check",
  1508.                           "progress"  : 20
  1509.                           ],
  1510.                        $[ "name"     : "find_swapable",
  1511.                                         // module method progress label
  1512.                           "summary"  : _("Searching for swap partitions..."),
  1513.                           "method"   : OSRPartitionCheckSwapAble,
  1514.                           "requires" :  [ "swap_partition_list" ],
  1515.                           "provides" :  [ "swapable_partitions" ],
  1516.                           "group"    :  "swap_check",
  1517.                           "progress" : 20
  1518.                           ],
  1519.                        $[ "name"     : "load_modules",
  1520.                                         // module method progress label
  1521.                           "summary"  : _("Installing kernel modules for file system support..."),
  1522.                           "method"   : OSRPartitionLoadAllFsModules,
  1523.                           "requires" : [],
  1524.                           "group"    : "fs_check",
  1525.                           "provides" :  ["fs_module_loaded"],
  1526.                           "progress" : 20
  1527.                           ],
  1528.                        $[ "name"     : "find_mounted",
  1529.                                         // module method progress label
  1530.                           "summary"  : _("Searching for currently mounted partitions..."),
  1531.                           "method"   : OSRPartitionCurrentlyMountedPartitions,
  1532.                           "requires" :  ["valid_target_list", "fs_module_loaded" ],
  1533.                           "provides" :  ["mounted_partitions"],
  1534.                           "group"    : "fs_check",
  1535.                           "progress" :  20
  1536.                        ],
  1537.                        $["name"  : "find_fscheck",
  1538.                                         // module method progress label
  1539.                           "summary"  : _("Found partitions for file system check"),
  1540.                           "method"   : OSRPartition2CheckPartitions,
  1541.                           "requires" :  [ "mounted_partitions" ],
  1542.                           "provides" :  [ "fsck_partitions"],
  1543.                           "group"    : "fs_check",
  1544.                           "progress" :  20
  1545.                        ],
  1546.                        $[ "name"     : "fsck",
  1547.                           "summary"  : "",
  1548.                           "method"   : OSRPartitionFSCheck,
  1549.                           "requires" :  [ "fsck_partitions" ],
  1550.                           "provides" :  [ "checked_partitions" ],
  1551.                           "group"    : "fs_check",
  1552.                           "progress" :  200
  1553.                        ],
  1554.                        $[ "name"     : "find_linux_partitions",
  1555.                                         // module method progress label
  1556.                           "summary"  : _("Searching for valid Linux partitions..."),
  1557.                           "method"   : OSRPartitionLinuxPartitions,
  1558.                           "requires" :  ["checked_partitions" ],
  1559.                           "provides" :  ["linux_partition_list"],
  1560.                           "group"    :  "fstab_check",
  1561.                           "progress" : 20
  1562.                            ],
  1563.                        $[ "name"     : "find_mountable_linux_partitions",
  1564.                                         // module method progress label
  1565.                           "summary"  : _("Searching for mountable partitions..."),
  1566.                           "method"   : OSRPartitionMountableLinuxPartitions,
  1567.                           "requires" :  ["linux_partition_list"],
  1568.                           "provides" :  ["mount_possible_list" ],
  1569.                           "group"    :  "fstab_check",
  1570.                           "progress" : 20
  1571.                           ],
  1572.                        $[ "name"     : "find_valid_root_partitions",
  1573.                                         // module method progress label
  1574.                           "summary"  : _("Searching for valid root partitions..."),
  1575.                           "method"   : OSRPartitionFindRootPartitions,
  1576.                           "requires" :  ["mount_possible_list"],
  1577.                           "provides" :  ["root_partition", "valid_root_partitions" ],
  1578.                           "group"    : "fstab_check",
  1579.                           "progress" : 20
  1580.                           ],
  1581.                        $[ "name"     : "mount_root",
  1582.                           "summary"  : "",
  1583.                           "method"   : OSRPartitionMountRoot,
  1584.                           "requires" :  [ "root_partition"],
  1585.                           "provides" :  ["root_mounted"   ],
  1586.                           "group"    : "fstab_check",
  1587.                           "progress" : 20
  1588.                           ],
  1589.                        $[ "name"     : "read_fstab",
  1590.                           "summary"  : "",
  1591.                           "method"   : OSRPartitionReadFstab,
  1592.                           "requires" :  [ "root_mounted"      ],
  1593.                           "provides" :  [ "fstab_readed"      ],
  1594.                           "group"    : "fstab_check",
  1595.                           "progress" : 20
  1596.                        ],
  1597.                        $[ "name"     : "check_root_entry",
  1598.                                         // module method progress label
  1599.                           "summary"  : _("Checking root file system entry of fstab..."),
  1600.                           "method"   : OSRPartitionCheckFstabRoot,
  1601.                           "requires" :  [ "fstab_readed"        ],
  1602.                           "provides" :  [ "fstab_root_checked"      ],
  1603.                           "group"    : "fstab_check",
  1604.                           "progress" : 20
  1605.                         ],
  1606.                        $[ "name"     : "check_entries",
  1607.                                         // module method progress label
  1608.                           "summary"  : _("Checking fstab entries..."),
  1609.                           "method"   : OSRPartitionCheckFstab,
  1610.                           "requires" :  [ "fstab_root_checked"      ],
  1611.                           "provides" :  [ "fstab_checked"       ],
  1612.                           "group"    : "fstab_check",
  1613.                           "progress" : 20
  1614.                        ]
  1615.            ],
  1616.            "direct_methods" : [
  1617.                    $[
  1618.  
  1619.                      "name"     : "direct_methods_custom_part",
  1620.                                       // module method action label
  1621.                      "button_text"  : _("Start Partitioning Tool"),
  1622.                                       // module method description
  1623.                      "description"  : _("
  1624. To resize, delete, or create a partition,
  1625. press this button
  1626. to start the YaST partitioning tool.
  1627. "),
  1628.                      "method"       : OSRDirectCustomPart,
  1629.                      "initial_only"     : true,
  1630.                      "visible"      : false,
  1631.                    ],
  1632.                      $[
  1633.  
  1634.                        "name"       : "direct_methods_recover_partition",
  1635.                                           // module method action label
  1636.                        "button_text"    : _("Recover Lost Partitions"),
  1637.                                           // module method description
  1638.                        "description"    : _("
  1639. If you have deleted or lost one or all
  1640. partitions of a hard disk accidentally,
  1641. press this button to attempt
  1642. recovery.
  1643. "),
  1644.                        "method"     : OSRDirectPartitionTable,
  1645.                        "initial_only"   : false,
  1646.                        "visible"    : true,
  1647.                      ],
  1648.                      $[
  1649.  
  1650.                        "name"       : "direct_methods_filesystem",
  1651.                                           // module method action label
  1652.                        "button_text"    : _("Repair File System"),
  1653.                                           // module method description
  1654.                        "description"    : _("
  1655. If the system crashed and you have a
  1656. corrupted file system, press
  1657. this button to scan and repair the file
  1658. system.
  1659. "),
  1660.                        "method"     : OSRDirectFilesystem,
  1661.                        "initial_only"   : false,
  1662.                        "visible"    : true
  1663.                      ],
  1664.                      $[
  1665.                        "name"       : "direct_methods_save",
  1666.                                           // module method action label
  1667.                        "button_text"    : _("Save System Settings to Floppy"),
  1668.                                           // module method description
  1669.                        "description"    : _("This can be helpful for later system checks. For example, it is possible to recover a lost partition
  1670. table with the stored system information.
  1671. "),
  1672.                        "method"     : OSRDirectSave2Floppy,
  1673.                        "initial_only"   : false,
  1674.                        "visible"    : true
  1675.                      ]
  1676.            ]
  1677.       ];
  1678.  
  1679.  
  1680.   };
  1681.  
  1682. }//EOF
  1683.