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 / StorageControllers.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  16.2 KB  |  625 lines
  1. /**
  2.  * Module:         StorageControllers.ycp
  3.  *
  4.  * Authors:        Klaus Kaempf <kkaempf@suse.de> (initial)
  5.  *
  6.  * Purpose:
  7.  * This module does all floppy disk related stuff:
  8.  * - Detect the floppy devices
  9.  *
  10.  * SCR: Read(.probe.storage)
  11.  *
  12.  * $Id: StorageControllers.ycp 27816 2006-02-10 10:51:47Z fehr $
  13.  */
  14. {
  15.     module "StorageControllers";
  16.  
  17.     import "Arch";
  18.     import "Mode";
  19.     import "ModulesConf";
  20.     import "ModuleLoading";
  21.     import "HwStatus";
  22.     import "Initrd";
  23.     import "Kernel";
  24.     import "Storage";
  25.     import "StorageDevices";
  26.     import "StorageClients";
  27.     import "Label";
  28.     import "Popup";
  29.     import "Linuxrc";
  30.  
  31.     textdomain "storage";
  32.  
  33.     // list of loaded modules and arguments 
  34.     // needed for modules.conf writing
  35.     // must be kept in order (-> no map !)
  36.     // must be searchable (-> separate lists for names and args)
  37.  
  38.     global list moduleNames = [];
  39.     global list moduleArgs = [];
  40.     global list moduleIDs = [];        //unique_id from probing
  41.  
  42.     list<list> ModToInitrdLx = [];
  43.     list<list> ModToInitrd = [];
  44.  
  45.     global string dasdParam = "";
  46.  
  47.     // --------------------------------------------------------------
  48.     // local values
  49.  
  50.     list controllers = [];    // set by "Probe"
  51.  
  52.     // remember postinstall modules (like imm and ppa)
  53.     //   which must be installed *last*
  54.  
  55.     list postinstall_names = [ "imm", "ppa" ];
  56.  
  57.     // postinstall modules information
  58.     // list of [ boolean modprobe,
  59.     //         string module_name,
  60.     //         string module_arg,
  61.     //         string vendor,
  62.     //         string device]
  63.  
  64.     list<list> postinstall_info = [];
  65.  
  66.     // --------------------------------------------------------------
  67.  
  68.  
  69. define list GetDasdList()
  70.     ``{
  71.     list ret = [];
  72.     list<map> dasd = (list<map>) SCR::Read(.proc.dasddev);
  73.     y2milestone( "dasd=%1", dasd );
  74.     foreach( map entry, dasd,
  75.     ``{
  76.     term a = `item( `id(entry["name"]:"") );
  77.     a = add( a, entry["name"]:"" );
  78.     a = add( a, entry["address"]:"" );
  79.     a = add( a, entry["state"]:"" );
  80.     ret = add( ret, a );
  81.     });
  82.     return( ret );
  83.     }
  84.  
  85. define string S390DasdParams()
  86.     ``{
  87.     SCR::UnmountAgent (.proc.modules);
  88.     map mod = (map)SCR::Read(.proc.modules);
  89.     boolean mod_loaded = haskey(mod, "dasd_mod");
  90.     y2milestone( "mod %1", mod );
  91.     string param = (string)SCR::Read(.etc.install_inf.DASD_Parameter);
  92.     if( param==nil )
  93.     {
  94.     param = "";
  95.     }
  96.     y2milestone( "param %1 size:%2", param, size(param) );
  97.     boolean do_load = !mod_loaded || size(param)==0;
  98.     if( do_load )
  99.     {
  100.     string okb = Label::AcceptButton();
  101.     // button text
  102.     string loadb = _("&Load Module");
  103.     // popup text
  104.     string text = sformat( 
  105. _("Here, enter the parameters with which to load
  106. the dasd module, such as dasd=FD00-FD0F,FD40.
  107. Press \"%1\" to load the 
  108. module.
  109. If the table shows the correct DASDs available,
  110. press \"%2\".
  111. "), deletechars(loadb,"&"), deletechars(okb,"&") );
  112.  
  113.     list cont = GetDasdList();
  114.     UI::OpenDialog(
  115.         `opt(`decorated),
  116.         `HBox(
  117.             `HSpacing(1),
  118.             `VBox(
  119.             `VSpacing(0.5),
  120.             // heading text
  121.             `Left(`Heading(_("DASD Module Parameter Setting"))),
  122.             `VSpacing(0.2),
  123.             `Left(`Label(text)),
  124.             `VSpacing(0.2),
  125.             `HBox(
  126.             // label text
  127.             `Left(`TextEntry(`id(`param), _("&DASD Parameter"), 
  128.                      param )),
  129.             `VSpacing(1),
  130.             `Bottom(`PushButton(`id(`load), loadb ))
  131.              ),
  132.             `VSpacing(1),
  133.             `HBox( 
  134.             `Table( `id(`dd_table), 
  135.                 // heading text
  136.                     `header( _("DASD Name"), 
  137.                 // heading text
  138.                          _("DASD Address"), 
  139.                 // heading text
  140.                          _("Status") ),
  141.                 cont ),
  142.             `VSpacing(10)
  143.              ),
  144.             `VSpacing(1),
  145.             `HBox(
  146.             `HStretch(),
  147.             `PushButton(`id(`abort), Label::AbortButton() ),
  148.             `HStretch(),
  149.             `PushButton(`id(`accept), Label::AcceptButton() ),
  150.             `HStretch()
  151.              ),
  152.             `VSpacing(0.5)
  153.             ),
  154.             `HSpacing(1)
  155.          ));
  156.     UI::SetFocus(`id(`param));
  157.     symbol ret = `none;
  158.     do
  159.         {
  160.         ret = (symbol)UI::UserInput();
  161.         y2milestone( "ret = %1", ret );
  162.         if( ret == `load )
  163.         {
  164.         if( mod_loaded )
  165.             {
  166.             SCR::Execute( .target.bash, 
  167.                           "/sbin/rmmod dasd_eckd_mod dasd_fba_mod dasd_mod" );
  168.             }
  169.         param = (string)UI::QueryWidget( `id(`param), `Value );
  170.         y2milestone( "param %1", param );
  171.         boolean ret = (boolean)SCR::Execute(.target.modprobe, "dasd_mod", param );
  172.         mod_loaded = true;
  173.         y2milestone( "ret=%1", ret );
  174.         if( !ret )
  175.             {
  176.             // popup text
  177.             Popup::Error( sformat(_("Error loading module dasd with 
  178. parameter: %1"), param ));
  179.             }
  180.         SCR::Execute(.target.modprobe, "dasd_eckd_mod", "" );
  181.         SCR::Execute(.target.modprobe, "dasd_fba_mod", "" );
  182.         cont = GetDasdList();
  183.         UI::ChangeWidget( `id(`dd_table), `Items, cont );
  184.         }
  185.         else if( ret == `accept && size(cont)==0 )
  186.         {
  187.         ret = `continue;
  188.         }
  189.         if( (ret == `accept||ret == `abort) && size(cont)==0 )
  190.         {
  191.         // popup text
  192.         Popup::Error( _("There are no DASD devices active.
  193. It is not possible to install without
  194. active DASD devices."));
  195.         }
  196.         }
  197.     while( ret != `accept && ret != `abort );
  198.     UI::CloseDialog();
  199.     }
  200.     y2milestone( "ret %1", param );
  201.     return( param );
  202.     }
  203.  
  204.     /**
  205.      * Probe storage controllers
  206.      * probing, loading modules
  207.      *
  208.      * @returns integer    number of controllers, 0 = none found 
  209.      */
  210. global define integer Probe ()
  211.     ``{
  212.     y2milestone( "StorageControllers::Probe()" );
  213.  
  214.     // probe 'storage' list
  215.  
  216.     controllers = (list<map>)SCR::Read (.probe.storage);
  217.  
  218.     if (!Arch::s390 () && size (controllers) == 0)
  219.     {
  220.     y2milestone("no controllers");
  221.     }
  222.     return size (controllers);
  223.     }
  224.  
  225.  
  226.  
  227. // --------------------------------------------------------------
  228.  
  229. // parportInitialize
  230.  
  231. define void parportInitialize ()
  232.     ``{
  233.     // post-load parport module
  234.     if ((size (postinstall_info) == 0) || Mode::test ())
  235.     {
  236.     return;
  237.     }
  238.  
  239.     boolean parport_loaded = false;
  240.     boolean parport_pc_loaded = false;
  241.  
  242.     foreach (list postlist, postinstall_info,
  243.     ``{
  244.     boolean post_modprobe = postlist[0]:false;
  245.     string post_name      = postlist[1]:"";
  246.     string post_arg          = postlist[2]:"";
  247.     string post_vendor    = postlist[3]:"";
  248.     string post_device    = postlist[4]:"";
  249.     if (!parport_loaded)
  250.         {
  251.         if( `ok == ModuleLoading::Load( "parport", "", post_vendor, 
  252.                                         post_device, Linuxrc::manual (), true ))
  253.         {
  254.         ModulesConf::ModuleArgs ("parport", "");
  255.         parport_loaded = true;
  256.         }
  257.         }
  258.     if( !parport_pc_loaded)
  259.         {
  260.         if( `ok == ModuleLoading::Load( "parport_pc", "", post_vendor, 
  261.                                         post_device, Linuxrc::manual (), true ))
  262.         {
  263.         ModulesConf::ModuleArgs ("parport_pc", "");
  264.         parport_pc_loaded = true;
  265.         }
  266.         }
  267.  
  268.     if( `ok == ModuleLoading::Load( post_name, post_arg, post_vendor, 
  269.                                     post_device, Linuxrc::manual (), post_modprobe))
  270.         {
  271.         ModulesConf::ModuleArgs (post_name, post_arg);
  272.         Kernel::AddModuleToLoad(post_name);
  273.  
  274.         moduleNames = add( moduleNames, post_name );
  275.         moduleArgs  = add( moduleArgs, post_arg );
  276.         y2milestone( "moduleNames %1", moduleNames );
  277.         y2milestone( "moduleArgs %1", moduleArgs );
  278.         }
  279.     });
  280.     return;
  281.     }
  282.  
  283. // start a controller (by loading its module)
  284. // return true if all necessary modules were actually loaded
  285. // return false if loading failed or was not necessary at all
  286.  
  287. define boolean startController (map controller)
  288.     ``{
  289.     // check module information
  290.     // skip controller if no module info available
  291.  
  292.     list<map> module_drivers = controller["drivers"]:[];
  293.     string module_id = controller["unique_key"]:"";
  294.  
  295.     if (size (module_drivers) == 0)
  296.     return false;
  297.  
  298.     // get list of modules from /proc/modules
  299.     SCR::UnmountAgent (.proc.modules);
  300.     map loaded_modules = (map)SCR::Read(.proc.modules);        
  301.  
  302.     // loop through all drivers checking if one is already active
  303.     // or if one is already listed in /proc/modules
  304.  
  305.     boolean already_active = false;
  306.     foreach (map modulemap, module_drivers,
  307.     ``{
  308.     if( modulemap["active"]:true ||
  309.         size( loaded_modules[modulemap["modules",0,0]:""]:$[] ) > 0 )
  310.         {
  311.         already_active = true;
  312.         if( modulemap["active"]:true )
  313.         {
  314.         ModToInitrdLx = add( ModToInitrdLx, 
  315.                              [ modulemap["modules",0,0]:"",
  316.                        modulemap["modules",0,1]:"" ] );
  317.         y2milestone( "startController ModToInitrdLx %1", ModToInitrdLx );
  318.         y2milestone( "startController ModToInitrd %1", ModToInitrd );
  319.         }
  320.         }
  321.     });
  322.  
  323.     // save unique key for HwStatus::Set()
  324.     string unique_key = controller["unique_key"]:"";
  325.  
  326.     if (already_active)
  327.     {
  328.     HwStatus::Set (unique_key, `yes);
  329.     return false;
  330.     }
  331.  
  332.     boolean stop_loading = false;
  333.     boolean one_module_failed = false;
  334.  
  335.     // loop through all drivers defined for this controller
  336.     // break after first successful load
  337.     //   no need to check "active", already done before !
  338.     foreach (map modulemap, module_drivers,
  339.     ``{
  340.     y2milestone ("startController modulemap: %1", modulemap);
  341.     boolean module_modprobe = modulemap["modprobe"]:false;
  342.  
  343.     boolean all_modules_loaded = true;
  344.  
  345.     if (!stop_loading)
  346.         {
  347.         foreach (list module_entry, modulemap["modules"]:[],
  348.         ``{
  349.         string module_name = module_entry[0]:"";
  350.         string module_args = module_entry[1]:"";
  351.  
  352.         // remember postinstall modules
  353.  
  354.         if( contains( postinstall_names, module_name) )
  355.             {
  356.             y2milestone("startController name: %1 args: %2", module_name, module_args);
  357.  
  358.             list vendor_device = 
  359.             ModuleLoading::prepareVendorDeviceInfo(controller);
  360.  
  361.             // save data for parportInitialize
  362.             postinstall_info = 
  363.             add( postinstall_info,
  364.                  [module_modprobe, module_name, module_args,
  365.                   vendor_device[0]:"", vendor_device[1]:""]);
  366.             }
  367.         else
  368.             {
  369.             // load module if not yet loaded
  370.             if( !contains (moduleNames, module_name) )
  371.             {
  372.             symbol load_result = `ok;
  373.             if( Linuxrc::manual () )
  374.                 {
  375.                 list vendor_device = 
  376.                 ModuleLoading::prepareVendorDeviceInfo(controller);
  377.                 load_result = 
  378.                 ModuleLoading::Load( module_name, module_args,
  379.                              vendor_device[0]:"",
  380.                              vendor_device[1]:"", true,
  381.                              module_modprobe );
  382.                 }
  383.             else
  384.                 {
  385.                 load_result = 
  386.                 ModuleLoading::Load( module_name, module_args,
  387.                              "", "", false, 
  388.                              module_modprobe );
  389.                 }
  390.             y2milestone( "startController load_result %1", load_result );
  391.  
  392.             if (load_result == `fail)
  393.                 {
  394.                 all_modules_loaded = false;
  395.                 }
  396.             else if (load_result == `dont)
  397.                 {
  398.                 all_modules_loaded = true;
  399.                 }
  400.             else        // load ok
  401.                 {
  402.                 // save data for modules.conf writing
  403.                 moduleNames = add (moduleNames, module_name);
  404.                 moduleArgs  = add (moduleArgs, module_args);
  405.                 moduleIDs  = add (moduleIDs, module_id);
  406.  
  407.                 y2milestone( "startController moduleNames %1", moduleNames );
  408.                 y2milestone( "startController moduleArgs %1", moduleArgs );
  409.                 y2milestone( "startController moduleIDs %1", moduleIDs );
  410.                 ModToInitrd = add( ModToInitrd, [ module_name,
  411.                                                   module_args ] );
  412.                 y2milestone( "startController ModToInitrd %1", ModToInitrd );
  413.                 y2milestone( "startController ModToInitrdLx %1", ModToInitrdLx );
  414.                 }
  415.             } // not yet loaded
  416.             } // not postinstall
  417.  
  418.         // break out of module load loop if one module failed
  419.  
  420.         if (!all_modules_loaded)
  421.             {
  422.             one_module_failed = true;
  423.             }
  424.         }); // foreach module of current driver info
  425.  
  426.         } // stop_loading
  427.  
  428.     // break out of driver load loop if all modules of
  429.     //   the current driver loaded successfully
  430.  
  431.     if (all_modules_loaded)
  432.         {
  433.         stop_loading = true;
  434.         }
  435.  
  436.     });  // foreach driver
  437.  
  438.     HwStatus::Set (unique_key, one_module_failed?`no:`yes);
  439.  
  440.     return (!one_module_failed);
  441.     }
  442.  
  443.  
  444. // local function to go through list of resources (list of maps)
  445. // checking if '"active":true' is set.
  446.  
  447. define boolean anyActive (list<map> resources)
  448. ``{
  449.     boolean active = size(resources)==0;
  450.  
  451.     foreach (map res, resources,
  452.     ``{
  453.     if (res["active"]:false)
  454.         active = true;
  455.     });
  456.  
  457.     return active;
  458. }
  459.  
  460. /**
  461.  * Start storage related USB and FireWire stuff
  462.  *
  463.  */
  464. global define void StartHotplugStorage ()
  465.     ``{
  466.     import "Hotplug";
  467.  
  468.     // If USB capable, there might be an usb storage device (i.e. ZIP)
  469.     // activate the module _last_ since it might interfere with other
  470.     // controllers (i.e. having usb-storage first might result in
  471.     // /dev/sda == zip which is bad if the zip drive is removed :-}).
  472.  
  473.     if (Hotplug::haveUSB)
  474.     {
  475.     // if loading of usb-storage is successful, re-probe for floppies
  476.     // again since USB ZIP drives are regarded as floppies.
  477.  
  478.     if (ModuleLoading::Load ("usb-storage", "", "", "USB Storage", Linuxrc::manual (), true) == `ok)
  479.     {
  480.         StorageDevices::FloppyReady();
  481.     }
  482.     }
  483.  
  484.     if (Hotplug::haveFireWire)
  485.     {
  486.     // load sbp2
  487.     ModuleLoading::Load ("sbp2", "", "", "SBP2 Protocol", Linuxrc::manual (), true);
  488.     }
  489.  
  490.     return;
  491. }
  492.  
  493. /**
  494.  * @param    none
  495.  * @returns void
  496.  * Init storage controllers (module loading)
  497.  * Must have called StorageControllers::probe() before !
  498. // O: list of [ loaded modules, module argument ]
  499.  */
  500.  
  501. global define void Initialize()
  502.     ``{
  503.     moduleNames = [];
  504.     moduleArgs = [];
  505.     map controller = $[];
  506.     integer cindex = 0;
  507.     list ioresources = [];
  508.     boolean module_loaded = false;
  509.  
  510.     ModToInitrd = [];
  511.     ModToInitrdLx = [];
  512.  
  513.     y2milestone("Initialize controllers: %1", controllers);
  514.  
  515.     // loop through all controller descriptions from hwprobe
  516.  
  517.     // use while(), continue not allowed in foreach()
  518.     while( !Arch::s390() && cindex < size(controllers) )
  519.     {
  520.     controller = controllers[cindex]:$[];
  521.     y2milestone( "Initialize controller %1", controller );
  522.  
  523.     if( size(controller["requires"]:[])>0 )
  524.         {
  525.         foreach( string s, controller["requires"]:[],
  526.         ``{
  527.         Storage::AddHwPackage( s );
  528.         });
  529.         }
  530.  
  531.     cindex = cindex + 1;
  532.  
  533.     // check BIOS resources on 'wintel' compatible systems
  534.     if (Arch::board_wintel ())
  535.     {
  536.         // for every controller it is checked whether
  537.         // the controller is disabled in BIOS
  538.         // this is done by checking for an active IO or memory resource
  539.  
  540.         if( !(anyActive (controller["resource", "io"]:[])
  541.           ||  anyActive (controller["resource", "mem"]:[])))
  542.         {
  543.         y2milestone( "Initialize controller %1 disabled in BIOS", 
  544.                  controller["device"]:"" );
  545.  
  546.         // continue if disabled in BIOS
  547.         continue;
  548.         }
  549.     }
  550.  
  551.     module_loaded = startController(controller) || module_loaded;
  552.     } // while (controller)
  553.  
  554.     y2milestone( "Initialize module_loaded %1", module_loaded );
  555.     y2milestone( "Initialize ModToInitrdLx %1 ModToInitrd %2 ", ModToInitrdLx,
  556.                  ModToInitrd );
  557.     ModToInitrd = (list<list>)union( ModToInitrdLx, ModToInitrd );
  558.     y2milestone( "Initialize ModToInitrd %1", ModToInitrd );
  559.  
  560.     if( size(ModToInitrd)>1 )
  561.     {
  562.     list<string> ls = filter( string s, 
  563.                               splitstring( (string)SCR::Read( .etc.install_inf.InitrdModules ), 
  564.                                " " ),
  565.                   ``(size(s)>0) );
  566.     y2milestone( "Initialize ls=%1", ls );
  567.     integer i = 0;
  568.     map lrmods = listmap( string s, ls, ``{i=i+1; return( $[ s : i ] );});
  569.     y2milestone( "Initialize lrmods=%1", lrmods );
  570.     i = 0;
  571.     while( i<size(ModToInitrd) )
  572.         {
  573.         integer j=i+1;
  574.         while( j<size(ModToInitrd) )
  575.         {
  576.         if( haskey( lrmods, ModToInitrd[i,0]:"" ) &&
  577.             haskey( lrmods, ModToInitrd[j,0]:"" ) &&
  578.             lrmods[ModToInitrd[i,0]:""]:0 > 
  579.             lrmods[ModToInitrd[j,0]:""]:0 )
  580.             {
  581.             list tmp = ModToInitrd[i]:[];
  582.             ModToInitrd[i] = ModToInitrd[j]:[];
  583.             ModToInitrd[j] = tmp;
  584.             }
  585.         j = j+1;
  586.         }
  587.         i=i+1;
  588.         }
  589.     y2milestone( "Initialize ModToInitrd %1", ModToInitrd );
  590.     }
  591.     foreach( list s, ModToInitrd,
  592.     ``{
  593.     Initrd::AddModule( s[0]:"", s[1]:"" );
  594.     });
  595.  
  596.     y2milestone( "Initialize postinstall_info %1", postinstall_info );
  597.  
  598.     parportInitialize ();
  599.  
  600.     // load all raid personalities
  601.     SCR::Execute(.target.modprobe, "raid0", "" );
  602.     SCR::Execute(.target.modprobe, "raid1", "" );
  603.     SCR::Execute(.target.modprobe, "raid5", "" );
  604.     SCR::Execute(.target.modprobe, "raid6", "" );
  605.     SCR::Execute(.target.modprobe, "multipath", "" );
  606.  
  607.     // init sw-RAID subsystem in the kernel
  608.     SCR::Execute( .target.bash, "/sbin/raidautorun");
  609.  
  610.     StartHotplugStorage();
  611.  
  612.     y2milestone("Initialize all controllers initialized module_loaded:%1",
  613.                 module_loaded );
  614.     StorageDevices::InitDone();
  615.     if( module_loaded )
  616.     Storage::ReReadTargetMap();
  617.     y2milestone( "Initialize calling EnablePopup()" );
  618.     StorageClients::EnablePopup();
  619.  
  620.     return;
  621.  
  622. }; // Initialize ()
  623.  
  624. }
  625.