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 / modules / OSRFsck.ycp < prev    next >
Text File  |  2006-11-29  |  20KB  |  781 lines
  1. /**
  2.  *  File:
  3.  *    OSRFsck.ycp
  4.  *
  5.  *  Module:
  6.  *    YaST OS Repair. Automatic error detection & repair tool for Linux.
  7.  *
  8.  *  Summary:
  9.  *    YaST OS Repair. Automatic error detection & repair tool for Linux.
  10.  *
  11.  *  Author:
  12.  *    Johannes Buchhold <jbuch@suse.de>
  13.  *
  14.  * $Id: OSRFsck.ycp 31106 2006-05-23 08:01:21Z jsuchome $
  15.  */
  16. {
  17.   module "OSRFsck";
  18.  
  19.   import "FileSystems";
  20.   import "FileUtils";
  21.   import "Storage";
  22.   import "Partitions";
  23.   import "Mode";
  24.   import "Popup";
  25.   import "Stage";
  26.  
  27.   import "OSRExecute";
  28.   import "OSRLogFile";
  29.   import "OSRModuleLoading";
  30.   import "OSRPopup";
  31.   import "OSRCommon";
  32.  
  33.   textdomain "repair";
  34.  
  35.   /**
  36.    * The last return value from a check_... call
  37.    */
  38.   integer last_check_return        = 0;
  39.  
  40.   /**
  41.    * Options for a repair call. Not Supported at the moment.
  42.    */
  43.   string  fsck_options            = "";
  44.  
  45.   /**
  46.    * The not loaded filesystem an lvm/raid modules.
  47.    */
  48.   global list<string> not_installed_modules = [];
  49.  
  50.   /**
  51.    * The loaded modules.
  52.    */
  53.   global list<string> fs_kernel_modules = [];
  54.  
  55.   /**
  56.    * A list of all possible filesystem id's for fsck...
  57.    */
  58.   global list fsck_fsid            = [];
  59.  
  60.   /**
  61.    * A list of all possible types for a fsck ...
  62.    */
  63.   global list<symbol> fsck_type        = [`sw_raid, `lvm, `logical, `primary];
  64.  
  65.   /**
  66.    * The partition name witch is currently in work ( checked - repaired)
  67.    */
  68.   string check_partition        = "";
  69.  
  70.   // prototypes of check/repair functions
  71.   define boolean is_ext2fs();
  72.   define boolean is_reiserfs();
  73.   define boolean is_xfs();
  74.   define boolean is_jfs();
  75.   define boolean is_fat();
  76.   define boolean is_ntfs();
  77.  
  78.   define boolean repair_ext2fs();
  79.   define boolean repair_reiserfs();
  80.   define boolean repair_xfs();
  81.   define boolean repair_jfs();
  82.  
  83.   define boolean check_ext2fs();
  84.   define boolean check_reiserfs();
  85.   define boolean check_xfs();
  86.   define boolean check_jfs();
  87.  
  88.   /**
  89.    * The find/check/repair define for all supported filesystems.
  90.    */
  91.   map fsck_map = $[
  92.             `ext2 : $[
  93.                 "find"        : is_ext2fs,
  94.                 "repair"    : repair_ext2fs,
  95.                 "check"        : check_ext2fs
  96.             ],
  97.             `ext3 :  $[
  98.                 "find"        : is_ext2fs,
  99.                 "repair"    : repair_ext2fs,
  100.                 "check"        : check_ext2fs
  101.             ],
  102.             `reiser: $[
  103.                 "find"        : is_reiserfs,
  104.                 "repair"    : repair_reiserfs,
  105.                 "check"        : check_reiserfs
  106.             ],
  107.             `xfs : $[
  108.                 "find"        : is_xfs,
  109.                 "repair"    : repair_xfs,
  110.                 "check"        : check_xfs
  111.             ],
  112.             `jfs : $[
  113.                 "find"        : is_jfs,
  114.                 "repair"    : repair_jfs,
  115.                 "check"        : check_jfs
  116.             ],
  117.             // "Do not touch non-linux partitions" (#25002)
  118.             // -> no check/repair functions for other filesystems
  119.             `fat16 : $[
  120.                 "find"        : is_fat
  121.             ],
  122.             `fat32 : $[
  123.                 "find"        : is_fat
  124.             ],
  125.             `ntfs : $[
  126.                 "find"        : is_ntfs
  127.             ]
  128.   ];
  129.  
  130.  
  131.   string file_name = "";
  132.  
  133.   global define void Reset()``{
  134.       file_name            = "";
  135.       last_check_return        = 0;
  136.       fsck_options        = "";
  137.       not_installed_modules    = [];
  138.       fs_kernel_modules        = [];
  139.       check_partition        = "";
  140.   }
  141.  
  142.   /**
  143.    * Constructor.
  144.    * Fill the list fsck_fsid with the date from module Partition.
  145.    */
  146.   global define void OSRFsck()``{
  147.  
  148.     fsck_fsid = union (Partitions::fsid_wintypes, Partitions::fsid_dostypes );
  149.     fsck_fsid = union (fsck_fsid, Partitions::fsid_ntfstypes );
  150.     fsck_fsid = union (fsck_fsid,
  151.     [ Partitions::fsid_native, Partitions::fsid_lvm, Partitions::fsid_raid  ]);
  152.   }
  153.  
  154.  
  155.   /**
  156.    * Load all needed fileystem and lvm/raid modules.
  157.    */
  158.   global define boolean LoadAllFsModules()``{
  159.  
  160.       if( Mode::test () )  return true;
  161.  
  162.       not_installed_modules = [];
  163.       fs_kernel_modules     = [];
  164.  
  165.       list all_supportet_fs = maplist (symbol fs, map details,
  166.         (map<symbol,map<any,any> >)FileSystems::GetAllFileSystems(false, false ), ``(fs) );
  167.  
  168.       foreach (symbol fs, (list<symbol>) all_supportet_fs , ``{
  169.       fs_kernel_modules = (list<string>) union (
  170.         fs_kernel_modules, FileSystems::GetNeededModules (fs));
  171.       });
  172.       fs_kernel_modules = (list<string>) union (
  173.     fs_kernel_modules , [ "xor", "raid0", "raid1", "raid5"]);
  174.  
  175.       // iterate all listed kernel modules
  176.       foreach(string fs_module, fs_kernel_modules, ``{
  177.       if (! OSRModuleLoading::Load( fs_module, "","","",false, true))
  178.           not_installed_modules = add (not_installed_modules, fs_module);
  179.       });
  180.  
  181.       return size( not_installed_modules ) == 0;
  182.   }
  183.  
  184.  
  185.  
  186.  
  187.   /**
  188.    * Return a list witch contains all partitions names that can be
  189.    * used for a fsck.
  190.    */
  191.   global define list<map> PossiblePartitions()``{
  192.  
  193.     list<map> partitions =    [];
  194.  
  195.     foreach(string dev, map target, Storage::GetTargetMap(), {
  196.     foreach(map p, target["partitions"]:[], {
  197.  
  198.         if (p["delete"]:false == false &&
  199.         (contains (fsck_fsid, p["fsid"]:0) || p["fstype"]:"" == "LV") &&
  200.         contains (fsck_type, p["type"]:`unknown))
  201.         {
  202.         partitions = add(partitions, p );
  203.         }
  204.     });
  205.     });
  206.  
  207.     y2milestone("all partitions %1", partitions);
  208.     return partitions;
  209.   }
  210.  
  211.  
  212.   define boolean is_unknown()``{
  213.       y2warning ("unkonwn file system");
  214.       return false;
  215.   }
  216.  
  217.   /**
  218.    *  Checks if the specified check_partition is of filesystem-type ext2fs.
  219.    *  @return boolean True if the check_partition is ext2fs.
  220.    */
  221.   define boolean is_ext2fs() ``{
  222.  
  223.     boolean isext2fs = OSRExecute::Command (
  224.     .local.bash, "/sbin/dumpe2fs -h " + check_partition);
  225.  
  226.     if (isext2fs )
  227.     y2milestone("partition %1 is ext2fs", check_partition);
  228.     else
  229.     y2milestone("partition %1 is NOT ext2fs", check_partition);
  230.  
  231.     return isext2fs;
  232.   };
  233.  
  234.   /**
  235.    *  Checks if the specified partition is of filesystem-type reiserfs.
  236.    *  @return boolean True if the partition is reiserfs.
  237.    */
  238.   define boolean is_reiserfs() ``{
  239.  
  240.     boolean isreiserfs = OSRExecute::Command (
  241.     .local.bash, "/sbin/debugreiserfs " + check_partition);
  242.  
  243.     if ( isreiserfs )
  244.     {
  245.     y2milestone("partition %1 is reiserfs", check_partition);
  246.     }
  247.     else
  248.     {
  249.     y2milestone("partition %1 is NOT reiserfs", check_partition);
  250.     }
  251.     return isreiserfs;
  252.   };
  253.  
  254.  
  255.   /**
  256.    *  Checks if the specified partition is of filesystem-type xfs.
  257.    *  @return boolean True if the partition is xfs.
  258.    */
  259.   define boolean is_xfs()``{
  260.  
  261.     boolean isxfs = OSRExecute::CommandOutput (
  262.     .local.bash, "/usr/sbin/xfs_admin -l -u " + check_partition);
  263.     // failed
  264.     //xfs_admin: unexpected XFS SB magic number 0xdd0a05a6
  265.     //bad sb magic # 0xdd0a05a6 in AG 0
  266.     //failed to read label in AG 0
  267.     //bad sb magic # 0xdd0a05a6 in AG 0
  268.     //failed to read UUID from AG 0
  269.  
  270.     // success
  271.     //label = ""
  272.     //uuid = ad743076-12b8-452b-86c0-2e62918479ae
  273.     if (issubstring (OSRExecute::stdout, "label") &&
  274.     issubstring (OSRExecute::stdout, "uuid" ))
  275.     {
  276.     y2milestone("partition %1 is xfs", check_partition);
  277.     isxfs = true;
  278.     }
  279.     else
  280.     {
  281.     y2milestone("partition %1 is NOT xfs", check_partition);
  282.     isxfs = false;
  283.     }
  284.     return isxfs;
  285.   };
  286.  
  287.   /**
  288.    *  Checks if the specified partition is of filesystem-type jfs.
  289.    *  @return boolean True if the partition is jfs.
  290.    */
  291.   define boolean is_jfs()``{
  292.  
  293.     if (!FileUtils::Exists ("/sbin/jfs_logdump"))
  294.     {
  295.     y2milestone ("/sbin/jfs_logdump not available, exiting check...");
  296.     return false;
  297.     }
  298.  
  299.     string command = sformat ("if /usr/bin/test -f %1; then /bin/rm %1; fi",
  300.     OSRLogFile::GetTmpDir() +"/jfslog.dmp" );
  301.  
  302.     // delete the old progress_file, if it exists
  303.     if (WFM::Execute(.local.bash, command) != 0)
  304.     {
  305.     y2error("The file %1 could not be deleted.",
  306.         OSRLogFile::GetTmpDir() +"/jfslog.dmp" );
  307.     }
  308.  
  309.     command        = sformat("cd %1; /sbin/jfs_logdump %2",
  310.     OSRLogFile::GetTmpDir(), check_partition );
  311.     boolean isjfs    = OSRExecute::CommandOutput (.local.bash, command );
  312.  
  313.     // check_jfs is 0 !! -> read jfslog.dmp
  314.     string jfslog    = (string) WFM::Read (.local.string,
  315.     OSRLogFile::GetTmpDir()+"/jfslog.dmp" );
  316.  
  317.     y2milestone("jfslog.dmp %1", jfslog);
  318.  
  319.     if (jfslog == nil || issubstring( jfslog, "?????????????????" ))
  320.     {
  321.     isjfs = false;
  322.     }
  323.     return isjfs;
  324.   };
  325.  
  326.  
  327.   /**
  328.    *  Checks if the specified partition is of filesystem-type fat/vfat.
  329.    *  @return boolean True if the partition is fat/vfat.
  330.    */
  331.   define boolean is_fat()``{
  332.  
  333.     string command    = sformat("/bin/guessfstype %1", check_partition );
  334.     boolean isfat    = OSRExecute::CommandOutput (.local.bash, command );
  335.  
  336.     if ( issubstring( OSRExecute::stdout, "fat" ))
  337.     {
  338.     isfat = true;
  339.     }
  340.     else
  341.     {
  342.     isfat = false;
  343.     }
  344.     return isfat;
  345.   };
  346.  
  347.   /**
  348.    *  Checks if the specified partition is of filesystem-type ntfs
  349.    *  @return boolean True if the partition is ntfs
  350.    */
  351.   define boolean is_ntfs()  ``{
  352.  
  353.     string command    = sformat("/bin/guessfstype %1", check_partition );
  354.     boolean isntfs    = false;
  355.     OSRExecute::CommandOutput (.local.bash, command );
  356.  
  357.     if (issubstring (OSRExecute::stdout, "ntfs" ))
  358.     isntfs = true;
  359.     return isntfs;
  360.   };
  361.  
  362.   /**
  363.    *  Checks the specified partition for consistency with "/sbin/e2fsck".
  364.    *  @return boolean
  365.    *    The exit code returned by e2fsck is the sum of the following conditions:
  366.    *      0 - No errors,
  367.    *      1 - File system errors corrected,
  368.    *      2 - File system errors corrected, system should be rebooted if file system was mounted,
  369.    *      4 - File system errors left uncorrected,
  370.    *      8 - Operational error,
  371.    *      16 - Usage or syntax error,
  372.    *      128 - Shared library error.
  373.    */
  374.   define boolean check_ext2fs() ``{
  375.  
  376.     string command    = sformat("/sbin/fsck.ext2 -n -f %1", check_partition );
  377.     boolean checkext2fs = OSRExecute::Command (.local.bash,command);
  378.     last_check_return    = OSRExecute::result;
  379.  
  380.     if (checkext2fs)
  381.     {
  382.     y2milestone("partition %1 is o.k., /sbin/e2fsck reports no errors",
  383.         check_partition);
  384.     }
  385.     else
  386.     {
  387.     y2error("/sbin/e2fsck reports an error: %1, command line: %2",
  388.         checkext2fs, command);
  389.     }
  390.     return checkext2fs;
  391.   };
  392.  
  393.   /**
  394.    *  Checks the specified partition for consistency with "/sbin/reiserfsck".
  395.    */
  396.   define boolean check_reiserfs() ``{
  397.  
  398.     string command = sformat("/bin/echo Yes | /sbin/reiserfsck --check %1",
  399.     check_partition);
  400.  
  401.     // don't use OSRExecute .. because OSRExecute use .target.bash_output and
  402.     // this break the whole Yast2 -> output is to much !! e.g. 14 MB
  403.     last_check_return        = (integer) WFM::Execute(.local.bash, command);
  404.     boolean checkreiserfs    = last_check_return == 0 ;
  405.  
  406.     if (checkreiserfs )
  407.     {
  408.     y2milestone("partition %1 is o.k., /sbin/reiserfsck reports no errors",
  409.         check_partition);
  410.     }
  411.     else
  412.     {
  413.     y2error("/sbin/reiserfsck reports an error: %1, command line: %2",
  414.         checkreiserfs, command);
  415.     }
  416.     return checkreiserfs;
  417.   };
  418.  
  419.   /**
  420.    * Checks the specified partition for consistency with "/sbin/xfs_db -c check".
  421.    */
  422.   define boolean check_xfs()``{
  423.  
  424.     string command = sformat("/usr/sbin/xfs_db -c check %1", check_partition);
  425.     boolean checkxfs    = OSRExecute::Command(.local.bash, command);
  426.     last_check_return   = OSRExecute::result;
  427.  
  428.     if (checkxfs)
  429.     {
  430.     y2milestone("partition %1 is o.k., xfs_check reports no errors",
  431.         check_partition);
  432.     }
  433.     else
  434.     {
  435.     y2milestone("xfs_check reports an error for partition %1",
  436.         check_partition );
  437.     }
  438.     return checkxfs;
  439.   };
  440.  
  441.   /**
  442.    * Checks the specified partition for consistency with "/sbin/fsck.jfs -n ".
  443.    */
  444.   define boolean check_jfs()``{
  445.  
  446.     if (!FileUtils::Exists ("/sbin/fsck.jfs"))
  447.     {
  448.     y2milestone ("/sbin/fsck.jfs not available, exiting check...");
  449.     return false;
  450.     }
  451.  
  452.     string command    = sformat("/sbin/fsck.jfs -n %1", check_partition);
  453.     boolean checkjfs    = OSRExecute::Command(.local.bash, command);
  454.     last_check_return    = OSRExecute::result;
  455.  
  456.     if (checkjfs)
  457.     {
  458.     y2milestone ("partition %1 is o.k., jfs_check reports no errors",
  459.         check_partition);
  460.     }
  461.     else
  462.     {
  463.     y2milestone("jfs_check reports an error for partition %1",
  464.         check_partition );
  465.     }
  466.     return checkjfs;
  467.   };
  468.  
  469. /**
  470.  * checks for filesystem type
  471.  * (Repair module should not touch non-linux partitions - bug #25002)
  472.  */
  473. global define boolean IsNonLinuxFileSystem (symbol fs) ``{
  474.  
  475.     return contains ([`ntfs, `fat16, `fat32], fs);
  476.  
  477. }
  478.  
  479. /**
  480.   * Test the filesystem of one partition.
  481.   * @param the partition map
  482.   */
  483. global define boolean Check(map part ) ``{
  484.     if(Mode::test () ) return true;
  485.  
  486.     symbol used_fs = part["detected_fs"]:`unknown;
  487.     check_partition = part["device"]:"";
  488.  
  489.     y2milestone("Check the file system of the partition %1", check_partition );
  490.     // find fs
  491.  
  492.     boolean () find_fs = fsck_map [used_fs, "find"]:is_unknown;
  493.     if (!find_fs ())
  494.     {
  495.     // ignore LVM partitions
  496.     if (part["fsid"]:0 == Partitions::fsid_lvm)
  497.     {
  498.         y2milestone("LVM group: no checks");
  499.         return true;
  500.     }
  501.  
  502.     y2error("used_fs is not ok or unknown. Searching for new filesystem");
  503.  
  504.     used_fs            = `unknown;
  505.     symbol new_used_fs = `unknown;
  506.  
  507.     foreach (symbol fs, map fs_map, (map<symbol,map<string,any> >)fsck_map, ``{
  508.         if ( fs != used_fs ) {
  509.         find_fs = fs_map["find"]:OSRCommon::False;
  510.         if (find_fs ())
  511.         {
  512.             new_used_fs = fs;
  513.         }
  514.         }
  515.     });
  516.     if ( new_used_fs != `unknown )
  517.         used_fs = new_used_fs;
  518.     else
  519.     {
  520.         y2error("no file systen found for %1", check_partition );
  521.     }
  522.     }
  523.     else
  524.     {
  525.     y2milestone("used_fs is ok. Executing file system check !!");
  526.     }
  527.     if ( used_fs != `unknown && used_fs != nil )
  528.     {
  529.     // ----------- start check now
  530.     if (IsNonLinuxFileSystem (used_fs))
  531.     {
  532.         y2milestone("non-linux filesystem: no checks");
  533.         return true;
  534.     }
  535.     boolean () f_check = fsck_map[used_fs, "check"]:OSRCommon::False;
  536.     if (f_check ())
  537.     {
  538.         y2milestone("file system check successful executed");
  539.         return true;
  540.     }
  541.     }
  542.     else
  543.     {
  544.     y2milestone("no file system found");
  545.     return nil;
  546.     }
  547.     y2error("file system check was not successful");
  548.     return false;
  549.   }
  550.  
  551.  
  552.  
  553.   /**
  554.    * The main repair dialog.
  555.    * @param t_check_partition the partition e.g.: /dev/hda1
  556.    * @param used_fs the filesystem symbol
  557.    * @return `ok,`error,`cancel
  558.    */
  559.   global define symbol Repair(string t_check_partition, symbol used_fs ) ``{
  560.  
  561.       // not used at the moment.
  562.       fsck_options   = "";
  563.  
  564.       file_name      = OSRLogFile::GetTmpDir()+ "/" + "fsck_repair";
  565.  
  566.       // makes global use possible ( from another define as Check);
  567.       check_partition = t_check_partition;
  568.  
  569.       // error message, %1 is filesystem type, %2 partition
  570.       string error_message = sformat(_("
  571. The %1 file system of the partition %2 is corrupted.
  572. To repair the file system, press Repair.
  573.  
  574. Press Skip if you do not want this repair.
  575. "), FileSystems::GetName( used_fs, "unkonwn"), check_partition );
  576.  
  577.       // error message
  578.       string help_text         = _("
  579. <p>An inconsistent file system occurs when
  580. a partition is not correctly unmounted.
  581. This could happen during a system crash.</p>
  582. ") +
  583.  
  584.       // error message
  585. _("<p>There is a repair method for each file
  586. system. For example, if the file system
  587. of the damaged partition is ext2 or
  588. ext3, use fsck.ext2 (e2fsck) with the
  589. corresponding options to repair the
  590. file system. The following lines list
  591. the repair tools of the different Linux
  592. file systems.</p>
  593. ") +
  594.  
  595. _("<p><pre>
  596. ext2 and ext2: fsck.ext2 or e2fsck
  597. reiserfs:      reiserfsck
  598. jfs:           fsck.jfs
  599. xfs:           xfs_repair
  600. msdos (fat):   fsck.msdos</pre></p>");
  601.  
  602.     // do not write about "closing YaST" when Mode::init?
  603.     if (!Stage::initial ())
  604.     help_text = help_text +
  605. _("<p>If you know what kind of file system
  606. you have and how to use the corresponding
  607. tool, close this program and repair the
  608. damaged file system on your own. Otherwise,
  609. close this help dialog and press 
  610. Repair for automatic repair.</p>
  611. ");
  612.  
  613.       while( true )
  614.       {
  615.       if (! OSRPopup::Repair(_("Error Detected"), error_message, help_text) ) return `cancel;
  616.  
  617.       UI::OpenDialog(`VBox(`VSpacing(1),
  618.                    `Label(_("Repairing file system...")),
  619.                    `VSpacing(1)));
  620.  
  621.       // if file exist
  622.       if( WFM::Execute(.local.bash, "/usr/bin/test -f " + file_name ) == 0 )
  623.       {
  624.           WFM::Execute(.local.bash, sformat ("/bin/rm %1", file_name) );
  625.       }
  626.  
  627.       boolean ret = true;
  628.       if( !Mode::test () )
  629.       {
  630.           boolean () f_rep = fsck_map [used_fs, "repair"]:OSRCommon::False;
  631.           ret = f_rep ();
  632.       }
  633.       UI::CloseDialog();
  634.  
  635.       string headline = "";
  636.  
  637.       if ( ret )
  638.       {
  639.           //%1 is file system, %2 is partition
  640.           headline = sformat(_("
  641. Successfully Repaired %1 on %2"),
  642.         FileSystems::GetName(used_fs, "unkonwn"), check_partition );
  643.       }
  644.       else
  645.       {
  646.           //%1 is file system, %2 is partition
  647.           headline = sformat(_("
  648. Failed Repair of %1 on %2"),
  649.         FileSystems::GetName(used_fs, "unkonwn"), check_partition );
  650.       }
  651.  
  652.       // if file exist
  653.       if( WFM::Execute(.local.bash, "/usr/bin/test -f " + file_name ) == 0 )
  654.       {
  655.           Popup::ShowFile( headline, file_name);
  656.       }
  657.  
  658.       if ( ret ) return `ok;
  659.       }
  660.   }
  661.  
  662.   /**
  663.    * Repair ext2/ext3 filesystem.
  664.    * The exit code returned by e2fsck is the sum of the following conditions:
  665.    *      0 - No errors,
  666.    *      1 - File system errors corrected,
  667.    *      2 - File system errors corrected, system should be rebooted if file system was mounted,
  668.    *      4 - File system errors left uncorrected,
  669.    *      8 - Operational error,
  670.    *      16 - Usage or syntax error,
  671.    *      128 - Shared library error.
  672.    */
  673.   define boolean repair_ext2fs()``{
  674.  
  675.     if (last_check_return == 4 )
  676.     {
  677.     y2milestone("repair ext2/ext3 filesystem on partition %1",
  678.         check_partition);
  679.  
  680.     string command        = sformat("/sbin/fsck.ext2 -p -f %1 %2",
  681.         fsck_options, check_partition );
  682.     boolean repairext2fs    = OSRExecute::CommandProgress (
  683.         .local.bash,command ,file_name);
  684.  
  685.     // TODO what is if fsck.ext2 requires y y y y for del indo XX ...
  686.     if (OSRExecute::result == 0 ||
  687.         OSRExecute::result == 1 ||
  688.         OSRExecute::result == 2 )
  689.     {
  690.         return true;
  691.     }
  692.     }
  693.     y2milestone("ext2 filesystem not successful repaired.");
  694.     return false;
  695.   }
  696.  
  697.   /**
  698.    * Repair reiserfs filesystem.
  699.    */
  700.   define boolean repair_reiserfs()``{
  701.  
  702.     string command        = "";
  703.     integer repairreiserfs    = 0;
  704.  
  705.     if ( last_check_return == 1 )
  706.     {
  707.     command = sformat("/bin/echo Yes | /sbin/reiserfsck --fix-fixable %1",
  708.         check_partition);
  709.     repairreiserfs = (integer) WFM::Execute (.local.bash, command);
  710.     }
  711.     else if ( last_check_return == 2 )
  712.     {
  713.     // popup headline, reiserfs is file system
  714.     if (Popup::AnyQuestion (_("Fatal Corruptions on reiserfs"),
  715.     // popup text (yes/no)
  716. _("
  717. Checking the file system (reiserfs) reports
  718. fatal corruptions. Only a rebuild of the reiserfs
  719. file system tree (reiserfsck --rebuild-tree)
  720. could solve the problem.
  721.  
  722. To rebuild your reiserfs tree,
  723. press Repair. Otherwise press
  724. Skip and repair the file system manually.
  725. "),
  726.         OSRPopup::repair_label, OSRPopup::skip_label,`focus_yes))
  727.     {
  728.         command =
  729.         sformat("/bin/echo Yes | /sbin/reiserfsck --rebuild-tree %1",
  730.         check_partition);
  731.         repairreiserfs = (integer) WFM::Execute (.local.bash,command);
  732.     }
  733.     else
  734.     {
  735.         return false;
  736.     }
  737.     }
  738.     if (repairreiserfs == 0 ||
  739.     repairreiserfs == 1 ||
  740.     repairreiserfs == 2 )
  741.     {
  742.     return true;
  743.     }
  744.     return false;
  745.   }
  746.  
  747.   /**
  748.    * Repair xfs filesystem.
  749.    */
  750.   define boolean repair_xfs()``{
  751.  
  752.     string command    = sformat("/sbin/xfs_repair %1", check_partition);
  753.     return OSRExecute::CommandProgress (.local.bash,command, file_name);
  754.   }
  755.  
  756.   /**
  757.    * Repair jfs filesystem.
  758.    */
  759.   define boolean repair_jfs()``{
  760.  
  761.     if (!FileUtils::Exists ("/sbin/fsck.jfs"))
  762.     {
  763.     y2milestone ("/sbin/fsck.jfs not available, exiting repair...");
  764.     return false;
  765.     }
  766.     string command    = sformat("/sbin/fsck.jfs -p %1", check_partition);
  767.     boolean repairjfs    = OSRExecute::CommandProgress (
  768.     .local.bash, command, file_name);
  769.  
  770.     if (OSRExecute::result == 0 ||
  771.     OSRExecute::result == 1 ||
  772.     OSRExecute::result == 2 )
  773.     {
  774.     return true;
  775.     }
  776.     y2milestone("jfs filesystem repair was not successful");
  777.     return false;
  778.   }
  779.  
  780. }//EOF
  781.