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 / ModuleLoading.ycp < prev    next >
Text File  |  2006-11-29  |  7KB  |  243 lines
  1. /**
  2.  * Module:        ModuleLoading.ycp
  3.  *
  4.  * Authors:        Klaus Kaempf <kkaempf@suse.de> (initial)
  5.  *
  6.  * Purpose:
  7.  * This module does all module loading stuff.
  8.  *
  9.  * $Id: ModuleLoading.ycp 25850 2005-10-10 13:38:49Z mvidner $
  10.  */
  11. {
  12.     module "ModuleLoading";
  13.  
  14.     textdomain "base";
  15.  
  16.     import "Mode";
  17. //    import "Initrd";
  18.     import "Label";
  19.  
  20.     string vendor_name = "";
  21.     string device_name = "";
  22.  
  23.     /**
  24.      * @param    map    controller
  25.      * @returns list    [string vendor, string device]
  26.      * Convert internal probing data to user readable string
  27.      * for module loading.
  28.      * @see ModuleLoading::Load
  29.      */
  30.  
  31.     global define list prepareVendorDeviceInfo (map controller)
  32.     ``{
  33.     // build up vendor/device information
  34.  
  35.     // if vendor not given, try sub_vendor
  36.  
  37.     string controller_vendor = controller["vendor"]:(controller["sub_vendor"]:"");
  38.     if (controller_vendor != "")
  39.     {
  40.         string controller_sub_vendor = controller["sub_vendor"]:"";
  41.         if (controller_sub_vendor != "")
  42.         {
  43.         controller_vendor = controller_vendor
  44.                 + "\n("
  45.                 + controller_sub_vendor
  46.                 + ")";
  47.         }
  48.     }
  49.  
  50.     // if device not given, try sub_device
  51.  
  52.     string controller_device = controller["device"]:(controller["sub_device"]:"");
  53.     if (controller_device != "")
  54.     {
  55.         string controller_sub_device = controller["sub_device"]:"";
  56.         if (controller_sub_device != "")
  57.         {
  58.         controller_device = controller_device
  59.                 + "\n("
  60.                 + controller_sub_device
  61.                 + ")";
  62.         }
  63.     }
  64.  
  65.     return [controller_vendor, controller_device];
  66.     };
  67.  
  68.     /**
  69.      * Cache for MarkedAsBroken
  70.      */
  71.     list<string> broken_modules = nil;
  72.  
  73.     /**
  74.      * Is the module marked as broken in install.inf? (BrokenModules)
  75.      * #97655
  76.      * @param mod module
  77.      * @return broken?
  78.      */
  79.     boolean MarkedAsBroken (string mod) {
  80.     if (broken_modules == nil)
  81.     {
  82.         string bms = (string)SCR::Read (.etc.install_inf.BrokenModules);
  83.         if (bms == nil)
  84.         {
  85.         bms = "";
  86.         }
  87.         broken_modules = splitstring (bms, " ");
  88.     }
  89.  
  90.     return contains (broken_modules, mod);
  91.     }
  92.  
  93.     /**
  94.      * @param    string modulename
  95.      * @param    string moduleargs
  96.      * @param    string vendorname
  97.      * @param    string devicename
  98.      * @param    boolean ask_before_loading
  99.      * @param    boolean with_modprobe
  100.      *
  101.      * @returns symbol:    `dont    user choose *not* to load module
  102.      *            `ok    module loaded ok
  103.      *            `fail    module loading failed
  104.      *
  105.      * load a module if not already loaded by linuxrc
  106.      */
  107.  
  108.     global define symbol Load (string modulename, string moduleargs,
  109.             string vendorname, string devicename,
  110.             boolean ask_before_loading, boolean with_modprobe)
  111.     ``{
  112.     if ((modulename != "")
  113. // there is no reason for checking initrd, if I need the module to get loaded, I just  need to
  114. // check if it isn't already loaded
  115. //        && (!contains (Initrd::ListModules (), modulename))
  116.         && !Mode::test ())
  117.     {
  118.         // always look whether the module is already loaded
  119.         map loaded_modules = (map) SCR::Read(.proc.modules);
  120.         if (size (loaded_modules[modulename]:$[]) > 0)
  121.         {
  122.         // already loaded
  123.         return `ok;
  124.         }
  125.  
  126.         // sformat( _("Loading module %1"), modulename);
  127.  
  128.         // #97655
  129.         if (MarkedAsBroken (modulename))
  130.         {
  131.         y2milestone ("In BrokenModules, skipping: %1", modulename);
  132.         return `dont;
  133.         }
  134.  
  135.         if (ask_before_loading && !Mode::autoinst())
  136.         {
  137.  
  138.         UI::OpenDialog(`opt(`decorated, `centered),
  139.                    `HBox (
  140.                       `HSpacing(1),
  141.                       `HCenter (
  142.                         `HSquash(
  143.                              `VBox (
  144.                                 `HCenter (
  145.                                       `HSquash(
  146.                                            `VBox(
  147.                                              // Popup-Box for manual driver installation.
  148.                                              // If the user selects 'manual installation' when
  149.                                              // booting from CD, YaST2 does not load any modules
  150.                                              // automatically, but asks the user for confirmation
  151.                                              // about every module.
  152.                                              // The popup box informs the user about the detected
  153.                                              // hardware and suggests a module to load.
  154.                                              // The user can confirm the module or change
  155.                                              // the suggested load command
  156.                                              //
  157.                                              // This is the heading of the popup box
  158.                                              `Left(`Heading(_("Confirm driver activation"))),
  159.                                              `VSpacing(0.2),
  160.                                              // This is in information message. Next come the
  161.                                              // vendor and device information strings as stored
  162.                                              // in the hardware-probing database.
  163.                                              `Left(`Label(_("YaST2 detected the following device"))),
  164.                                              `Left(`Label(vendorname)),
  165.                                              `Left(`Label(devicename)),
  166.                                              `VSpacing(0.1),
  167.                                              // Caption for Textentry with module information
  168.                                              `Left(`TextEntry(`id(`mod_name), _("&Driver/Module to load"), modulename+" "+moduleargs))
  169.                                              )
  170.                                            )
  171.                                       ),
  172.                                 `HSquash(
  173.                                      `HBox(
  174.                                            `HWeight( 1, `PushButton(`id(`ok_msg), `opt(`default), Label::OKButton())),
  175.                                            `HSpacing(2),
  176.                                            `HWeight( 1, `PushButton(`id(`cancel_msg), Label::CancelButton()))
  177.                                            )
  178.                                      ),
  179.                                 `VSpacing(0.2)
  180.                                 )
  181.                              )
  182.                         ),
  183.                       `HSpacing(1)
  184.                       )
  185.                    );
  186.           UI::SetFocus (`id(`ok_msg));
  187.           symbol ret = (symbol) UI::UserInput();
  188.           if (ret == `ok_msg)
  189.           {
  190.               string module_data = (string) UI::QueryWidget(`id(`mod_name), `Value);
  191.               if (size (module_data) > 0)
  192.               {
  193.               // skip leading spaces
  194.               integer firstspace = findfirstnotof (module_data, " ");
  195.               if (firstspace != nil)
  196.               {
  197.                   module_data = substring (module_data, firstspace);
  198.               }
  199.  
  200.               // split name and args
  201.               firstspace = findfirstof (module_data, " ");
  202.  
  203.               if (firstspace == nil)
  204.               {
  205.                   modulename = module_data;
  206.                   moduleargs = "";
  207.               }
  208.               else
  209.               {
  210.                   modulename = substring (module_data, 0, firstspace);
  211.                   moduleargs = substring (module_data, firstspace+1);
  212.               }
  213.               }
  214.           }
  215.           UI::CloseDialog();
  216.  
  217.           if (ret == `cancel_msg)
  218.           {
  219.               y2milestone ("NOT loaded module %1 %2", modulename, moduleargs);
  220.               return `dont;
  221.           }
  222.         } // ask_before_loading
  223.     }
  224.  
  225.     boolean load_success = false;
  226.     if (with_modprobe)
  227.     {
  228.         load_success = (boolean) SCR::Execute(.target.modprobe, modulename, moduleargs);
  229.     }
  230.     else
  231.     {
  232.         load_success = (boolean) SCR::Execute(.target.insmod, modulename, moduleargs);
  233.     }
  234.     if (load_success == nil)
  235.         load_success = false;
  236.  
  237.     y2milestone ("Loaded module %1 %2 %3", modulename, moduleargs, load_success?"Ok":"Failed");
  238.  
  239.     return (load_success?`ok:`fail);
  240.     };
  241.  
  242. }
  243.