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 / FileSystems.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  44.7 KB  |  1,436 lines
  1. /**
  2.  * Module:         FileSystems.ycp
  3.  *
  4.  * Authors:        Johannes Buchhold (jbuch@suse.de)
  5.  *
  6.  * Purpose:
  7.  * These module contains the supported filesystems and their settings.
  8.  *
  9.  *
  10.  * $Id: FileSystems.ycp 33346 2006-10-12 10:47:02Z fehr $
  11.  */
  12. {
  13.   module "FileSystems";
  14.   textdomain "storage";
  15.   import "Arch";
  16.   import "String";
  17.   import "Partitions";
  18.   import "Popup";
  19.   import "Encoding";
  20.  
  21.   import "Mode";
  22.   import "Stage";
  23.  
  24.   import "LibStorage";
  25.   import "LibStorage::StorageInterface";
  26.   import "LibStorage::FsCapabilities";
  27.  
  28. global map<string,any> conv_fs =
  29.     $[ "def_sym" : `unknown,
  30.        "def_int" : LibStorage::FSUNKNOWN(),
  31.        "m" : $[ LibStorage::REISERFS() : `reiser,
  32.                 LibStorage::EXT2() : `ext2,
  33.                 LibStorage::EXT3() : `ext3,
  34.                 LibStorage::VFAT() : `vfat,
  35.                 LibStorage::XFS() : `xfs,
  36.                 LibStorage::JFS() : `jfs,
  37.                 LibStorage::HFS() : `hfs,
  38.                 LibStorage::NTFS() : `ntfs,
  39.                 LibStorage::SWAP() : `swap,
  40.                 LibStorage::FSNONE() : `none
  41.               ]
  42.      ];
  43.  
  44. integer fromSymbol( map<string,any> conv, symbol val )
  45.     {
  46.     integer ret = conv["def_int"]:-1;
  47.     foreach( integer i, symbol s, conv["m"]:$[],
  48.         ``{
  49.         if( s==val )
  50.             ret = i;
  51.         });
  52.     return( ret );
  53.     }
  54.  
  55.   global list<string> system_m_points = [ "/", "/usr", "/var", "/opt", 
  56.                                           Partitions::BootMount() ];
  57.   global list<string> crypt_m_points = [ "/", Partitions::BootMount(), "/usr" ];
  58.   global list<string> suggest_m_points = (list<string>)union( system_m_points,
  59.                                         [ "/home", "/srv", "/tmp", "/local", ""] );
  60.   global list<string> swap_m_points   = [ "swap", ""  ];
  61.  
  62.   global string nchars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  63.  
  64. define list FstabOptionStrings = 
  65.     [ "defaults", 
  66.       "auto", "noauto",
  67.       "atime", "noatime",
  68.       "ro", "rw",
  69.       "user", "nouser",
  70.       "acl", "noacl",
  71.       "user_xattr", "no_user_xattr",
  72.       "data=journal", "data=ordered", "data=writeback",
  73.       "dev", "nodev", 
  74.       "exec", "noexec", 
  75.       "suid", "nosuid", 
  76.       "async", "sync", "dirsync",
  77.       "procuid", 
  78.       "barrier=none",
  79.       "fs=floppyfss", "fs=cdfss",
  80.       "users", "gid=users"
  81.       ];
  82.  
  83. define list FstabOptionRegex = [ "pri=[0-9]\+", "iocharset=.\+", "utf8=\.*",
  84.                                  "nls=.\+", "codepage=.\+", 
  85.                  "gid=[0-9]\+", "umask=[0-7]\+",
  86.                  "loop=.\+", "encryption=.\+",
  87.                  "pri=[0-9]\+" ];
  88.  
  89. define map FstabDefaultMap =
  90.     $[ "pts":    $[ "spec":"devpts", "mount":"/dev/pts", "vfstype":"devpts",
  91.             "mntops":"mode=0620,gid=5", "freq":0, "passno":0 ],
  92.        "proc":   $[ "spec":"proc", "mount":"/proc", "vfstype":"proc", 
  93.                     "mntops":"defaults", "freq":0, "passno":0 ],
  94.        "sys":    $[ "spec":"sysfs", "mount":"/sys", "vfstype":"sysfs", 
  95.                     "mntops":"noauto", "freq":0, "passno":0 ],
  96.        "debug":  $[ "spec":"debugfs", "mount":"/sys/kernel/debug", 
  97.                     "vfstype":"debugfs", "mntops":"noauto", 
  98.             "freq":0, "passno":0 ],
  99.        "swap":   $[ "spec":"", "mount":"swap", "vfstype":"swap", 
  100.                     "mntops":"default", "freq":0, "passno":0 ],
  101.        "root":   $[ "spec":"", "mount":"", "vfstype":"auto", 
  102.                     "mntops":"defaults", "freq":1, "passno":1 ],
  103.        "dev":    $[ "spec":"", "mount":"", "vfstype":"auto", 
  104.                     "mntops":"noauto,user", "freq":0, "passno":0 ],
  105.        "nfs":    $[ "spec":"", "mount":"", "vfstype":"nfs", 
  106.                     "mntops":"defaults", "freq":0, "passno":0 ],
  107.        "usb":    $[ "spec":"usbfs", "mount":"/proc/bus/usb", "vfstype":"usbfs", 
  108.                     "mntops":"noauto", "freq":0, "passno":0 ],
  109.        "cdrom":  $[ "spec":"", "mount":"", "vfstype":"subfs", 
  110.                     "mntops":"noauto,fs=cdfss,ro,procuid,nosuid,nodev,exec", 
  111.             "freq":0, "passno":0 ],
  112.        "floppy":    $[ "spec":"", "mount":"", "vfstype":"auto", 
  113.                     "mntops":"noauto,user,sync", "freq":0, "passno":0 ],
  114.        "zip":    $[ "spec":"", "mount":"", "vfstype":"auto", 
  115.                     "mntops":"noauto,user", "freq":0, "passno":0 ],
  116.        "data":   $[ "spec":"", "mount":"", "vfstype":"auto", 
  117.                     "mntops":"noauto,user", "freq":0, "passno":0 ]
  118.      ];
  119.  
  120.   /* All supported filesystems */
  121.   map<symbol, boolean> support     = $[
  122.            `reiser    : true,
  123.            `xfs        : true,
  124.            `ext2        : true,
  125.            `ext3        : true,
  126.            `jfs        : true,
  127.            `vfat      : true,
  128.            `xxefi      : false,
  129.            `xbootdisk      : false,
  130.            `xbootfat      : false,
  131.            `xhibernate     : true,
  132.            `raid           : true,
  133.            `lvm            : true
  134.   ];
  135.  
  136.   list<symbol> unsupportFs = [ `jfs ];
  137.  
  138.   map<symbol, map<string, any> > capabilities = $[
  139.            `reiser    : $[
  140.                              "extend":true,
  141.                      "shrink":true,
  142.                              "mount_extend":true,
  143.                      "uuid" : true,
  144.                      "label_length" : 16,
  145.                      "label" : true
  146.                    ],
  147.            `xfs        : $[
  148.                              "extend":true,
  149.                              "mount_extend":true,
  150.                      "label_length" : 12,
  151.                      "set_label_mount" : true,
  152.                      "uuid" : true,
  153.                      "label" : true
  154.                    ],
  155.            `ext2        : $[
  156.                              "extend":true,
  157.                              "shrink":true,
  158.                      "uuid" : true,
  159.                      "label_length" : 16,
  160.                      "set_label_mount" : true,
  161.                      "label" : true
  162.                    ],
  163.            `ext3        : $[ "extend":true,
  164.                              "shrink":true,
  165.                      "uuid" : true,
  166.                      "label_length" : 16,
  167.                      "set_label_mount" : true,
  168.                      "label" : true
  169.                    ],
  170.            `jfs        : $[
  171.                    ],
  172.            `hfs        : $[
  173.                    ],
  174.            `vfat      : $[ "shrink":true
  175.                    ],
  176.            `ntfs      : $[ "extend":true,
  177.                              "shrink":true
  178.                    ],
  179.            `swap      : $[ "extend":true,
  180.                              "shrink":true,
  181.                    ],
  182.            `unknown      : $[
  183.                    ],
  184.   ];
  185.  
  186.  
  187.  
  188.     /**
  189.      * Return a map that contains the mount option for each used_fs (-t)
  190.      * @return map
  191.      */
  192.   /*
  193.     to mount_string
  194.     global define used2typeMap()
  195.     ``{
  196.     return $[
  197.          `ext2   : "ext2",
  198.          `ext3   : "ext3",
  199.          `reiser : "reiserfs",
  200.          `xfs    : "xfs",
  201.          `jfs    : "jfs",
  202.          `vfat   : "vfat" ];
  203.     };
  204.   */
  205.  
  206. global define list<map<symbol, any> > GetGeneralFstabOptions()
  207.     ``{
  208.     list<map<symbol, any> > options =
  209.     [ $[
  210.          // button text
  211.          `widget : `Left(`CheckBox(`id("opt_readonly"), _("Mount &read-only"), false)),
  212.          `query_key : "opt_readonly",
  213.          // help text, richtext format
  214.          `help_text : _("<p><b>Mount Read-Only:</b>
  215. No writable access to the file system is possible. Default is false.</p>
  216. "),
  217.              `type : `boolean,
  218.          `str_opt : $[ 1 : "ro", "default" : "" ],
  219.          `str_scan : [[ "ro", 1 ], ["rw", 0 ]],
  220.        ],
  221.       $[
  222.          // button text
  223.          `widget : `Left(`CheckBox(`id("opt_noatime"), _("No &access time"), false)),
  224.          `query_key : "opt_noatime",
  225.          // help text, richtext format
  226.          `help_text : _("<p><b>No access time:</b>
  227. Access times are not updated when a file is read. Default is false.</p>"),
  228.              `type : `boolean,
  229.          `str_opt  : $[ 1 : "noatime", "default" : "" ],
  230.          `str_scan : [[ "noatime", 1 ], ["atime", 0 ]],
  231.        ],
  232.       $[
  233.          // button text
  234.          `widget : `Left(`CheckBox(`id("opt_user"), _("Mountable by &user"), false)),
  235.          `query_key : "opt_user",
  236.          // help text, richtext format
  237.          `help_text : _("<p><b>Mountable by User:</b>
  238. The file system may be mounted by an ordinary user. Default is false.</p>
  239. "),
  240.              `type : `boolean,
  241.          `str_opt  : $[ 1 : "user", "default" : "" ],
  242.          `str_scan : [[ "nouser", 0 ], ["user", 1 ]],
  243.        ],
  244.       $[
  245.          // button text
  246.          `widget : `Left(`CheckBox(`id("opt_noauto"), `opt(`notify), _("Do Not Mount at System &Start-up"), false)),
  247.          `query_key : "opt_noauto",
  248.          // help text, richtext format
  249.          `help_text : _("<p><b>Not Mounted at System Start-up:</b>
  250. The file system is not automatically mounted when the system starts.
  251. An entry in /etc/fstab is created and the file system is mounted
  252. with the appropriate options when the command <tt>mount <mount point></tt>
  253. (<mount point> is the directory to which the file system is mounted)
  254. is given. Default is false.</p>
  255. "),
  256.              `type : `boolean,
  257.          `str_opt  : $[ 1 : "noauto", "default" : "" ],
  258.          `str_scan : [[ "noauto", 1 ], ["auto", 0 ]],
  259.        ]
  260.     ];
  261.     return( options );
  262.     };
  263.  
  264. global define list< map<symbol, any> > GetJournalFstabOptions()
  265.     ``{
  266.     list< map<symbol, any> > options =
  267.     [ $[
  268.          `widget : `VBox( `ComboBox(`id("opt_journal"), `opt(`hstretch),
  269.                     // label text
  270.                     _("Data &Journaling Mode"),
  271.                     ["journal", "ordered", "writeback"]),
  272.                   `VSpacing(0.5)),
  273.          `default   : "ordered",
  274.          `query_key : "opt_journal",
  275.          `type : `text,
  276.          // help text, richtext format
  277.          `help_text : _("<p><b>Data Journaling Mode:</b>
  278. Specifies the journaling mode for file data.
  279. <tt>journal</tt> -- All data is committed into the journal prior to being
  280. written into the main file system.
  281. <tt>ordered</tt> -- All data is forced directly out to the main file system
  282. prior to its metadata being committed to the journal.
  283. <tt>writeback</tt> -- Data ordering is not preserved.</p>
  284. "),
  285.          `str_opt : "data=%1",
  286.          `str_scan : "data=\(.*\)"
  287.        ]
  288.     ];
  289.     return( options );
  290.     };
  291.  
  292. global define list< map<symbol, any> > GetAclFstabOptions()
  293.     ``{
  294.     list< map<symbol, any> > options =
  295.     [ $[
  296.          // button text
  297.          `widget : `Left(`CheckBox(`id("opt_acl"), _("&Access Control Lists (ACL)"), false)),
  298.          `query_key : "opt_acl",
  299.          // help text, richtext format
  300.          `help_text : _("<p><b>Access Control Lists (ACL):</b>
  301. Enable access control lists on the file system.</p>
  302. "),
  303.              `type : `boolean,
  304.          `default : true,
  305.          `str_opt : $[ 0 : "noacl", "default" : "acl" ],
  306.          `str_scan : [[ "acl", 1 ], ["noacl", 0 ]],
  307.        ],
  308.       $[
  309.          // button text
  310.          `widget : `Left(`CheckBox(`id("opt_eua"), _("&Extended User Attributes"), false)),
  311.          `query_key : "opt_eua",
  312.          // help text, richtext format
  313.          `help_text : _("<p><b>Extended User Attributes:</b>
  314. Allow extended user attributes on the file system.</p>
  315. "),
  316.              `type : `boolean,
  317.          `str_opt  : $[ 1 : "user_xattr", "default" : "" ],
  318.          `str_scan : [[ "user_xattr", 1 ], ["no_user_xattr", 0 ]],
  319.        ],
  320.     ];
  321.     return( options );
  322.     };
  323.  
  324. global define map<symbol, any> GetArbitraryOptionField()
  325.     ``{
  326.     map<symbol,any> opt = $[
  327.          // label text
  328.          `widget : `TextEntry(`id("opt_arbitrary"), _("Arbitrary option &value"), ""),
  329.          `query_key : "opt_arbitrary",
  330.          // help text, richtext format
  331.          `help_text : _("<p><b>Arbitrary Option Value:</b>
  332. In this field, type any legal mount option allowed in the fourth field of /etc/fstab.
  333. Multiple options are separated by commas.</p>
  334. "),
  335.              `type : `text
  336.        ];
  337.     return( opt );
  338.     };
  339.  
  340. define map<symbol, map<symbol, any> > GetNormalFilesystems()``{
  341.  
  342.   list< map<symbol, any> > fat_fst_options =
  343.       [
  344.     $[
  345.        // label text
  346.        `widget : `ComboBox(`id("opt_iocharset"), `opt(`editable,`hstretch), _("Char&set for file names"),
  347.                            ["", "iso8859-1", "iso8859-15", "iso8859-2",
  348.                     "iso8859-5", "iso8859-7", "iso8859-9", "utf8",
  349.                     "koi8-r", "euc-jp", "sjis", "gb2312", "big5", "euc-kr" ]),
  350.        `query_key : "opt_iocharset",
  351.        `type : `text,
  352.          // help text, richtext format
  353.        `help_text : _("<p><b>Charset for File Names:</b>
  354. Set the charset used for display of file names in Windows partitions.</p>
  355. "),
  356.        `str_opt : "iocharset=%1",
  357.        `str_scan : "iocharset=\(.*\)"
  358.      ],
  359.     $[
  360.        // label text
  361.        `widget : `ComboBox(`id("opt_codepage"), `opt(`editable,`hstretch), _("Code&page for short FAT names"),
  362.                            ["", "437", "852", "932", "936", "949", "950" ]),
  363.        `query_key : "opt_codepage",
  364.        `type : `text,
  365.          // help text, richtext format
  366.        `help_text : _("<p><b>Codepage for Short FAT Names:</b>
  367. This codepage is used for converting to shortname characters on FAT file systems.</p>
  368. "),
  369.        `str_opt : "codepage=%1",
  370.        `str_scan : "codepage=\(.*\)"
  371.      ]
  372.       ];
  373.  
  374.   list< map<symbol, any> > vfat_options =
  375.       [
  376.        $[
  377.      // label text
  378.      `widget        : `ComboBox(`id("opt_number_of_fats"), `opt(`hstretch), _("Number of &FATs"), ["auto" , "1", "2"  ]),
  379.      `query_key    : "opt_number_of_fats",
  380.      `option_str    : "-f",
  381.          // help text, richtext format
  382.      `help_text    : _("<p><b>Number of FATs:</b>
  383. Specify the number of file allocation tables in the file system. The default is 2.</p>")
  384.        ],
  385.      $[
  386.      // label text
  387.        `widget    : `ComboBox(`id("opt_fat_size"), `opt(`hstretch), _("FAT &size"), ["auto",
  388.                                               `item(`id("12"), "12 bit"),
  389.                                               `item(`id("16"), "16 bit"),
  390.                                               `item(`id("32"), "32 bit") ]),
  391.        `query_key     : "opt_fat_size",
  392.        `option_str    : "-F",
  393.          // help text, richtext format
  394.        `help_text    : _("<p><b>FAT size:</b>
  395. Specifies the type of file allocation tables used (12,  16,  or  32-bit). If auto is specified, YaST2 will automatically select the value most suitable for the file system size.</p>
  396. ")
  397.      ],
  398.      $[
  399.      // label text
  400.        `widget     : `TextEntry(`id("opt_root_dir_entries"), `opt(`hstretch), _("Root &dir entries"), "auto"),
  401.        `query_key     : "opt_root_dir_entries",
  402.        `option_str    : "-r",
  403.        `between    : [ 112, -1],
  404.        `valid_chars : "0123456789",
  405.        // popup text
  406.        `error_text     : _("The minimum size for \"Root dir entries\" is 112. Please try again."),
  407.          // help text, richtext format
  408.        `help_text    : _("<p><b>Root dir entries:</b>
  409. Select the number of entries available in the root directory.</p>")
  410.      ]
  411.   ];
  412.  
  413.  
  414.   list< map<symbol, any> > reiserfs_options =   [
  415.                  $[
  416.                    // label text
  417.                    `widget         : `ComboBox(`id("opt_hash"), `opt(`hstretch), _("Hash &function"), ["auto", "r5", "tea" ,"rupasov" ]),
  418.                    `query_key        : "opt_hash",
  419.                    `option_str    : "--hash",
  420.                    `option_blank    : true,
  421.          // help text, richtext format
  422.                    `help_text        : _("<p><b>Hash function:</b>
  423. This specifies the name of the hash function to use to sort the file names in directories.</p>")
  424.                  ],
  425.                    $[
  426.                    // label text
  427.                  `widget         : `ComboBox(`id("opt_format"), `opt(`hstretch), _("FS &revision"), ["auto", "3.5", "3.6" ]),
  428.                  `query_key        : "opt_format",
  429.                  `option_str    : "--format",
  430.                      `option_blank  : true,
  431.          // help text, richtext format
  432.                  `help_text        : _("<p><b>FS revision:</b>
  433. This option defines the reiserfs format revision to use. '3.5' is for backwards compatibility with kernels of the 2.2.x series. '3.6' is more recent, but can only be used with kernel versions greater than or equal to 2.4.</p>
  434. ")
  435.                    ]
  436.   ];
  437.  
  438.  
  439.   list< map<symbol, any> > xfs_options    =  [
  440.                   $[
  441.                  // label text
  442.                    `widget         : `ComboBox(`id("opt_blocksize"), `opt(`hstretch), _("Block &size in bytes"), ["auto","512","1024", "2048","4096" /*,"8192", "16384","32768"*/ ]),
  443.                    `query_key    : "opt_blocksize",
  444.                    `option_str    : "-bsize=",
  445.          // help text, richtext format
  446.                    `help_text      : _("<p><b>Block size:</b>
  447. Specify the size of blocks in bytes. Valid block size values are 512, 1024, 2048, and 4096 bytes per block. If auto is selected, the standard block size of 4096 is used.</p>
  448. ")
  449.                  ],
  450.                   $[
  451.                    // label text
  452.                 `widget       : `ComboBox(`id("opt_bytes_per_inode"), `opt(`hstretch), _("&Inode Size"),["auto","256", "512", "1024", "2048"]),
  453.                 `query_key    : "opt_bytes_per_inode",
  454.                 `option_str      : "-isize=",
  455.          // help text, richtext format
  456.                 `help_text      : _("<p><b>Inode Size:</b>
  457. This option specifies the inode size of the file system.</p>\n")
  458.                   ],
  459.                   $[
  460.                    // label text
  461.                 `widget       : `ComboBox(`id("opt_max_inode_space"), `opt(`hstretch), _("&Percentage of inode space"),["auto", "5", "10", "15", "20","25","30",
  462.                                                                      "35", "40", "45", "50", "55", "60", "65",
  463.                                                                      "70", "75", "80", "85", "90", "95",
  464.                                                                      `item(`id("0"), "100") ]),
  465.                 `query_key    : "opt_max_inode_space",
  466.                 `option_str      : "-imaxpct=",
  467.          // help text, richtext format
  468.                 `help_text      : _("<p><b>Percentage of inode space:</b>
  469. The option \"Percentage of inode space\" specifies the maximum percentage of space in the file system that can be allocated to inodes.</p>
  470. ")
  471.                   ],
  472.                   $[
  473.                    // label text
  474.                 `widget       : `ComboBox(`id("opt_inode_align"), `opt(`hstretch), _("Inode &aligned"),[ "auto", `item(`id("1"), "true"),
  475.                                                              `item( `id("0"), "false")  ]),
  476.                 `query_key    : "opt_inode_align",
  477.                 `option_str      : "-ialign=",
  478.          // help text, richtext format
  479.                 `help_text      : _("<p><b>Inode Aligned:</b>
  480. The option \"Inode Aligned\" is used to specify whether inode allocation is or
  481. is not aligned. The default is that inodes are aligned. Aligned inode access
  482. is normally more efficient than unaligned access.</p>
  483. ")
  484.                   ]
  485.   ];
  486.  
  487.  
  488.   list< map<symbol, any> > jfs_options = [
  489.         $[
  490.        // label text
  491.        `widget : `ComboBox(`id("opt_iocharset"), `opt(`editable,`hstretch), _("Char&set for file names"),
  492.                            ["", "iso8859-1", "iso8859-15", "iso8859-2",
  493.                     "iso8859-5", "iso8859-7", "iso8859-9", "utf8",
  494.                     "koi8-r", "euc-jp", "sjis", "gb2312", "big5", "euc-kr" ]),
  495.        `query_key : "opt_iocharset",
  496.        `type : `text,
  497.          // help text, richtext format
  498.        `help_text : _("<p><b>Charset for File Names:</b>
  499. Set the charset used to display file names on the partition.</p>\n"),
  500.        `str_opt : "iocharset=%1",
  501.        `str_scan : "iocharset=\(.*\)"
  502.      ],
  503.               $[
  504.                // label text
  505.             `widget         : `TextEntry(`id("opt_log_size"), `opt(`hstretch),_("&Log size in megabytes"), "auto"),
  506.             `query_key    : "opt_log_size",
  507.             `option_str    : "-ls:",
  508.             // no way to find out the max log size ????
  509.             `between        : [ 0 , -1 ], //  -> -1 = infinite
  510.             `valid_chars     : "0123456789",
  511.                // popup text
  512.             `error_text     : _("The \"Log size\" value is incorrect.\nPlease enter a value greater than zero."),
  513.             // xgettext: no-c-format
  514.          // help text, richtext format
  515.             `help_text      : _("<p><b>Log size</b>
  516. Set the log size (in megabytes). If auto, the default is 40% of the aggregate size.</p>")
  517.               ],
  518.               $[
  519.                // label text
  520.             `widget        : `CheckBox(`id("opt_blocks_utility"), _("Invoke Bad Blocks List &Utility"), false),
  521.             `query_key    : "opt_blocks_utility",
  522.             `option_str    : "-l"
  523.               ]
  524.   ];
  525.  
  526.   list< map<symbol, any> > ext2_options  =  [
  527.                    $[
  528.                  // label text
  529.                  `widget         : `TextEntry(`id("opt_raid"), `opt(`hstretch), _("Stride &length in blocks"), "none" ),
  530.                  `query_key    : "opt_raid",
  531.                  `option_str    : "-Rstride=",
  532.                  `valid_chars    : "0123456789",
  533.                  `between        : [ 1, -1],
  534.                  // popup text
  535.                  `error_text    : _("The \"Stride length in blocks\" value is not possible.\nPlease select a value greater than 1."),
  536.          // help text, richtext format
  537.                  `help_text    : _("<p><b>Stride Length in Blocks:</b>
  538. Set RAID-related options for the file system. Currently, the only supported
  539. argument is 'stride', which takes the number of blocks in a
  540. RAID stripe as its argument.</p>
  541. ")
  542.                    ],
  543.                  $[
  544.                  // label text
  545.                    `widget         : `ComboBox(`id("opt_blocksize"), `opt(`hstretch), _("Block &size in bytes"), ["auto","1024", "2048","4096" /*,"8192", "16384","32768"*/ ]),
  546.                    `query_key    : "opt_blocksize",
  547.                    `option_str    : "-b",
  548.          // help text, richtext format
  549.                    `help_text      : _("<p><b>Block size:</b>
  550. Specify the size of blocks in bytes. Valid block size values are 1024, 2048, and 4096 bytes per block. If auto is selected, the block size is determined by the file system size and the expected use of the file system.</p>\n")
  551.                  ],
  552.                  $[
  553.                    // label text
  554.                    `widget       : `ComboBox(`id("opt_inode_density"), `opt(`hstretch), _("Bytes per &inode"),["auto","1024", "2048","4096","8192", "16384","32768" ]),
  555.                    `query_key    : "opt_inode_density",
  556.                    `option_str     : "-i",
  557.          // help text, richtext format
  558.                    `help_text      : _("<p><b>Bytes per inode:</b>
  559. Specify the bytes to inode ratio. YaST2 creates an inode for every <bytes-per-inode> bytes of space on the disk. The larger the bytes-per-inode ratio, the fewer inodes will be created.
  560. Generally, this value should not be smaller than the block size of the file system, since too many inodes will be created in this case.  It is not possible to expand the
  561. number of inodes on a file system after its creation, so be sure to enter a reasonable value for this parameter.</p>
  562. ")
  563.                  ],
  564.                  $[
  565.                    // label text
  566.                    `widget       : `TextEntry(`id("opt_reserved_blocks"), `opt(`hstretch), _("Percentage of blocks &reserved for root"), "auto" ),
  567.                    `query_key    : "opt_reserved_blocks",
  568.                    `option_str  : "-m",
  569.                    //`default     : 5,
  570.                    `between    : [ 0 , 99 ], //  -> -1 = infinite
  571.                    `str_length    : 2,
  572.                    `valid_chars : "0123456789",
  573.                    // popup text
  574.                    `error_text  : _("The \"Percentage of blocks reserved for root\" value is incorrect.\nPlease use a value between 0 and 99."),
  575.                    // xgettext: no-c-format
  576.          // help text, richtext format
  577.                    `help_text      : _("<p><b>Percentage of blocks reserved for root:</b> Specify the percentage of blocks reserved for the super user. This value defaults to 5%.</p>")
  578.                  ]
  579.       ];
  580.  
  581.   list< map<symbol, any> > ext3_only_options = [
  582.       $[
  583.       // label text
  584.       `widget       : `ComboBox(`id("opt_bytes_per_inode"), `opt(`hstretch), _("&Inode Size"),["default", "128", "256", "512", "1024"]),
  585.       `query_key    : "opt_bytes_per_inode",
  586.       `option_str      : "-I",
  587.        // help text, richtext format
  588.       `help_text      : _("<p><b>Inode Size:</b>
  589. This option specifies the inode size of the file system.</p>\n")
  590.       ],
  591.       $[
  592.       // label text
  593.       `widget       : `CheckBox(`id("opt_dir_index"), `opt(`hstretch), _("&Directory Index Feature")),
  594.       `query_key    : "opt_dir_index",
  595.       `option_str      : "-O dir_index",
  596.       `type             : `boolean,
  597.       `default          : false,
  598.        // help text, richtext format
  599.       `help_text      : _("<p><b>Directory Index:</b>
  600. Enables use of hashed b-trees to speed up lookups in large directories.</p>\n")
  601.       ]
  602.   ];
  603.  
  604.   list< map<symbol, any> > ext3_options = (list< map<symbol, any> >)merge( ext2_options, ext3_only_options );
  605.  
  606.   list< map<symbol, any> > ext3_fst_options = [ ];
  607.   list< map<symbol, any> > ext2_fst_options = [ ];
  608.   list< map<symbol, any> > reiser_fst_options = [ ];
  609.  
  610.  
  611.   map <symbol, map<symbol, any> > RealFileSystems  = $[
  612.               `ext2    : $[
  613.                     `name         : "Ext2",
  614.                     `fsid         : Partitions::fsid_native,
  615.                     `supports_format     : true,
  616.                     `fsid_item         : "0x83 Linux ",
  617.                     `fstype         : "Linux native" ,
  618.                     `crypt         : true ,
  619.                     `mountpoints     : suggest_m_points,
  620.                     `mount_option    : "-t ext2",
  621.                     `mount_string    : "ext2",
  622.                     `makefstype        : "ext2",
  623.                     `fst_options      : ext2_fst_options,
  624.                     `options          : ext2_options,
  625.               ],
  626.               `vfat    : $[
  627.                     `name         : "FAT",
  628.                     `fsid         : 12,
  629.                     `alt_fsid           : [ 12, 0x103 ],
  630.                     `supports_format     : true ,
  631.                     `fsid_item         : "0x0C Win95 FAT32 ",
  632.                     `fstype         : "Fat32",
  633.                     `crypt         : true ,
  634.                     `mountpoints     : suggest_m_points ,
  635.                     `mount_option    : "-t vfat",
  636.                     `mount_string    : "vfat",
  637.                     `makefstype        : "fat32",
  638.                     `needed_modules    : [ "fat", "vfat" ],
  639.                     `fst_options      : fat_fst_options,
  640.                     `options         : vfat_options
  641.  
  642.               ],
  643.               `reiser     : $[
  644.                     `name         : "Reiser",
  645.                     `fsid         : Partitions::fsid_native,
  646.                     `supports_format     : true ,
  647.                     `fsid_item         : "0x83 Linux " ,
  648.                     `fstype         : "Linux native",
  649.                     `crypt         : true,
  650.                     `mountpoints     : suggest_m_points,
  651.                     `mount_option     : "-t reiserfs",
  652.                     `mount_string    : "reiserfs",
  653.                     `needed_modules    : [ "reiserfs" ],
  654.                     `makefstype        : "reiserfs",
  655.                     `fst_options      : reiser_fst_options,
  656.                     `options         : reiserfs_options
  657.               ],
  658.               `xfs     : $[
  659.                     `name         : "XFS",
  660.                     `fsid         : Partitions::fsid_native,
  661.                     `supports_format     : true ,
  662.                     `fsid_item         : "0x83 Linux " ,
  663.                     `fstype         : "Linux native" ,
  664.                     `crypt         : true,
  665.                     `mountpoints     : suggest_m_points,
  666.                     `mount_option     : "-t xfs",
  667.                     `mount_string    : "xfs",
  668.                     `needed_modules    : [ "xfs" ],
  669.                     `makefstype        : "xfs",
  670.                     `options         : xfs_options
  671.               ],
  672.               `jfs     : $[
  673.                     `name         : "JFS",
  674.                     `fsid         : Partitions::fsid_native,
  675.                     `supports_format     : true ,
  676.                     `fsid_item         : "0x83 Linux " ,
  677.                     `fstype         : "Linux native" ,
  678.                     `crypt        : true,
  679.                     `mountpoints     : suggest_m_points,
  680.                     `mount_string    : "jfs",
  681.                     `mount_option    : "-t jfs",
  682.                     `needed_modules    : [ "jfs" ],
  683.                     `makefstype        : "jfs",
  684.                     `options          : jfs_options
  685.               ],
  686.               `ext3     : $[
  687.                     `name         : "Ext3",
  688.                     `fsid         : Partitions::fsid_native,
  689.                     `supports_format     : true ,
  690.                     `fsid_item         : "0x83 Linux " ,
  691.                     `fstype         : "Linux native" ,
  692.                     `crypt        : true,
  693.                     `mountpoints     : suggest_m_points,
  694.                     `mount_string    : "ext3",
  695.                     `mount_option    : "-t ext3",
  696.                     `needed_modules    : [ "jbd",  "ext3" ],
  697.                     `makefstype        : "ext2", // format ext3 as ext2 !!!!!!!!!!!!!!!
  698.                     `fst_options      : ext3_fst_options,
  699.                     `options          : ext3_options
  700.               ],
  701.               `hfs     : $[
  702.                     `name         : "MacHFS",
  703.                     `fsid         : Partitions::fsid_mac_hfs,
  704.                     `supports_format     : true,
  705.                     `fsid_item         : "0x102 Apple_HFS " ,
  706.                     `fstype         : "Apple_HFS " ,
  707.                     `crypt        : false,
  708.                     `mountpoints     : [],
  709.                     `mount_string    : "hfs",
  710.                     `mount_option    : "-t hfs",
  711.                     `needed_modules    : [ "hfs" ],
  712.                     `makefstype        : "hfs",
  713.                     `fst_options      : [],
  714.                     `options          : []
  715.               ]
  716.   ];
  717.  
  718.   return( RealFileSystems );
  719.   };
  720.  
  721.   list< map<symbol, any> > swap_fst_options = [
  722.     $[ `widget         : `TextEntry( `id("priority"), `opt(`hstretch),
  723.                   // label text
  724.                                   _("Swap &Priority"), "42" ),
  725.        `query_key   : "priority",
  726.        `between        : [ 0, 32767],
  727.        `empty_allowed : true,
  728.        `valid_chars : "0123456789",
  729.        // popup text
  730.        `error_text  : _("Value must be between 0 and 32767. Try again."),
  731.        `type : `text,
  732.        `str_opt : "pri=%1",
  733.        `str_scan : "pri=\(.*\)",
  734.      // help text, richtext format
  735.        `help_text   : _("<p><b>Swap Priority:</b>
  736. Enter the swap priority. Higher numbers mean higher priority.</p>
  737. ")
  738.      ]];
  739.  
  740.   map<symbol, any> SwapFileSystems =
  741.     $[ `swap :
  742.     $[ `name         : "Swap" ,
  743.        `fsid         : Partitions::fsid_swap,
  744.        `supports_format : true ,
  745.        `fsid_item         : "0x82 Linux swap ",
  746.        `fstype         : "Linux swap",
  747.        `crypt         : false,
  748.        `fst_options     : swap_fst_options,
  749.        `mountpoints     : swap_m_points
  750.      ]
  751.      ];
  752.  
  753.  
  754.   map<symbol, map<symbol, any> > PseudoFileSystems = $[
  755.                 `lvm    : $[
  756.                         `name         : "LVM",
  757.                         `fsid         : Partitions::fsid_lvm,
  758.                         `supports_format     : false,
  759.                         `fsid_item         : "0x8E Linux LVM "
  760.                 ],
  761.                 `raid    : $[
  762.                         `name         : "RAID",
  763.                         `fsid         : Partitions::fsid_raid,
  764.                         `supports_format     : false,
  765.                         `fsid_item         : "0xFD Linux RAID "
  766.                 ],
  767.                 `xbootdisk : $[
  768.                        `name         : "PPCBOOT",
  769.                        `fsid         : Partitions::fsid_prep_chrp_boot,
  770.                        `supports_format     : false,
  771.                        `fsid_item         : "0x41 PPC PReP Boot"
  772.                 ],
  773.                 `xbootfat  : $[
  774.                        `name         : "FATBOOT",
  775.                        `fsid         : Partitions::fsid_fat16,
  776.                        `supports_format     : false,
  777.                        `fsid_item         : "0x06 FAT16 Boot"
  778.                 ],
  779.                 `xhibernate : $[
  780.                        `name         : "Hibernate",
  781.                        `fsid         : Partitions::fsid_hibernation,
  782.                        `supports_format     : false,
  783.                        `fsid_item         : "0xA0 Hibernation"
  784.                        ],
  785.                 `xxefi      : $[
  786.                                `name                : "Efi Boot",
  787.                        `fsid                : Partitions::fsid_gpt_boot,
  788.                        `supports_format     : false,
  789.                        `fsid_item           : "0x103 EFI Boot"
  790.                        ]
  791.   ];
  792.  
  793.  
  794.   /**
  795.    * Filesystem Definitions
  796.    * @return map map with all supported filesystems
  797.    */
  798. global define map<symbol, map<symbol, any> > GetAllFileSystems(boolean add_swap, boolean add_pseudo )
  799.     ``{ 
  800.     map<symbol, map<symbol, any> > ret = filter( symbol fs_key, map<symbol,any> fs_map, GetNormalFilesystems(),
  801.                       ``( support[fs_key]:false ));
  802.  
  803.     if( add_swap )
  804.     {
  805.     ret = (map<symbol, map<symbol, any> >)union( ret, SwapFileSystems );
  806.     }
  807.     if( add_pseudo )
  808.     {
  809.     ret = (map<symbol, map<symbol, any> >)union( ret, filter( symbol fs_key, any fs_map, PseudoFileSystems,
  810.                   ``( support[fs_key]:false )));
  811.     }
  812.     return ret;
  813.     }
  814.  
  815.  
  816. global define list< map<symbol, any> > GetFstabOptWidgets( symbol fsys )
  817.     ``{
  818.     list< map<symbol, any> > ret = [];
  819.     if( fsys != `swap )
  820.     {
  821.     map<symbol, map<symbol, any> > fs = GetAllFileSystems( true, false );
  822.     ret = fs[fsys,`fst_options]:[];
  823.     if( contains( [`ext3, `reiser], fsys ) )
  824.         {
  825.         ret = (list< map<symbol, any> >)union( ret, GetJournalFstabOptions() );
  826.         }
  827.     if( contains( [`ext2, `ext3, `reiser], fsys ) )
  828.         {
  829.         ret = (list< map<symbol, any> >)union( ret, GetAclFstabOptions() );
  830.         }
  831.     }
  832.     else
  833.     {
  834.     ret = swap_fst_options;
  835.     }
  836.     y2milestone( "fsys %1", fsys );
  837.     y2milestone( "ret %1", ret );
  838.     return( ret );
  839.     };
  840.  
  841.  
  842.  
  843.  
  844.   /* FileS build fss map with all supported filesystems ( list support ) */
  845. global define void FileSystems()
  846.     ``{
  847.     if( Arch::sparc64() || Arch::sparc32() )
  848.     {
  849.         support[`vfat] = false;
  850.     }
  851.     if( Arch::ppc() )
  852.     {
  853.     support[`vfat] = Arch::board_chrp();
  854.     support[`xbootdisk] = true;
  855.     support[`xbootfat] = Arch::board_chrp();
  856.     }
  857.     if( Arch::s390() )
  858.     {
  859.     support[`xfs] = false;
  860.     support[`vfat] = false;
  861.     }
  862.     if( Arch::ia64() )
  863.     {
  864.     support[`jfs] = false;
  865.     support[`xxefi] = true;
  866.     }
  867.     if( Arch::alpha() )
  868.     {
  869.     support[`reiser] = false;
  870.     }
  871.     if( Arch::board_mac() )
  872.     {
  873.     support[`hfs] = true;
  874.     }
  875.     y2milestone( "support %1", support );
  876.     suggest_m_points = [ "/home", "/srv", "/tmp", "/local", ""];
  877.     if( Stage::initial() )
  878.     suggest_m_points = (list<string>)union( system_m_points, 
  879.                                             suggest_m_points );
  880.     y2milestone( "suggest_m_points:%1", suggest_m_points );
  881.     }
  882.  
  883. global define void InitSlib( any sint )
  884.     {
  885.     boolean bval = false;
  886.     integer val = 0;
  887.     foreach( symbol fs, map<string,any> cap, capabilities,
  888.     ``{
  889.     if( fs != `unknown )
  890.         {
  891.         integer id = fromSymbol( conv_fs, fs );
  892.         any fsinfo = LibStorage::FsCapabilities::new("LibStorage::FsCapabilities");
  893.         boolean ret = LibStorage::StorageInterface::getFsCapabilities( sint, id, fsinfo );
  894.         if( !ret )
  895.         y2error( "InitSlib fs:%1 id:%2 ret:%3", fs, id, ret );
  896.         else
  897.         {
  898.         cap = $[];
  899.         bval = LibStorage::FsCapabilities::swig_isExtendable_get(fsinfo);
  900.         if( bval )
  901.             cap["extend"] = true;
  902.         bval = LibStorage::FsCapabilities::swig_isReduceable_get(fsinfo);
  903.         if( bval )
  904.             cap["shrink"] = true;
  905.         bval = LibStorage::FsCapabilities::swig_isExtendableWhileMounted_get(fsinfo);
  906.         if( bval )
  907.             cap["mount_extend"] = true;
  908.         bval = LibStorage::FsCapabilities::swig_isReduceableWhileMounted_get(fsinfo);
  909.         if( bval )
  910.             cap["mount_shrink"] = true;
  911.         bval = LibStorage::FsCapabilities::swig_supportsUuid_get(fsinfo);
  912.         if( bval )
  913.             cap["uuid"] = true;
  914.         bval = LibStorage::FsCapabilities::swig_supportsLabel_get(fsinfo);
  915.         if( bval )
  916.             cap["label"] = true;
  917.         bval = LibStorage::FsCapabilities::swig_labelWhileMounted_get(fsinfo);
  918.         if( bval )
  919.             cap["set_label_mount"] = true;
  920.         if( cap["label"]:false )
  921.             cap["label_length"] = LibStorage::FsCapabilities::swig_labelLength_get(fsinfo);
  922.         cap["min_fs_k"] = LibStorage::FsCapabilities::swig_minimalFsSizeK_get(fsinfo);
  923.         capabilities[fs] = cap;
  924.         }
  925.         }
  926.     });
  927.     }
  928.  
  929.  
  930. global define boolean IsSupported( symbol used_fs)
  931.     ``{
  932.     return support[ used_fs ]:false;
  933.     }
  934.  
  935. global define boolean IsUnsupported( symbol used_fs)
  936.     ``{
  937.     return( contains( unsupportFs, used_fs ));
  938.     }
  939.  
  940. global define map<symbol, any> GetFsMap( symbol used_fs )
  941.     ``{
  942.     map<symbol, map<symbol, any> > allfs =  GetAllFileSystems( true, true  );
  943.     if( haskey( allfs, used_fs ))
  944.     return allfs[ used_fs]:$[];
  945.     else
  946.     {
  947.     map<symbol, map<symbol, any> > fs = GetNormalFilesystems();
  948.     return( fs[used_fs]:$[] );
  949.     }
  950.     }
  951.  
  952.   global define string GetName( symbol used_fs, string defaultv )``{
  953.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  954.       string ret        = fsmap[`name]:"";
  955.       if ( ret == "" && used_fs == `ntfs ) ret = "NTFS";
  956.       if ( ret == "" ) ret = defaultv;
  957.       return ret;
  958.   }
  959.  
  960.   global define integer GetFsid( symbol used_fs )``{
  961.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  962.       return fsmap[`fsid]:Partitions::fsid_native;
  963.   }
  964.  
  965.   global define boolean GetSupportFormat( symbol used_fs )``{
  966.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  967.       return (boolean)(fsmap[`supports_format]:nil);
  968.   }
  969.  
  970.   global define string GetFsidItem( symbol used_fs )``{
  971.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  972.       return fsmap[`fsid_item ]:"";
  973.   }
  974.  
  975.   global define string GetFstype( symbol used_fs )``{
  976.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  977.       return fsmap[`fstype ]:"";
  978.   }
  979.  
  980.   global define boolean GetCrypt( symbol used_fs )``{
  981.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  982.       return (boolean)(fsmap[`crypt ]:nil);
  983.   }
  984.  
  985.   global define list GetPossibleMountPoints( symbol used_fs )``{
  986.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  987.       return fsmap[`mountpoints ]:[];
  988.   }
  989.  
  990.   global define string GetMountOption( symbol used_fs )``{
  991.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  992.       return fsmap[`mount_option ]:"";
  993.   }
  994.  
  995.   global define list GetOptions( symbol used_fs )``{
  996.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  997.       return fsmap[`options ]:[];
  998.   }
  999.  
  1000.  
  1001.     /**
  1002.      * Return the mount option for each used_fs (-t)
  1003.      * @return string
  1004.      */
  1005.   global define string GetMountString(symbol used_fs, string defaultv )``{
  1006.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  1007.       string ret        = fsmap[`mount_string ]:"";
  1008.       if( size(ret)==0 )
  1009.       {
  1010.       if( used_fs == `vfat )
  1011.           {
  1012.           ret = "vfat";
  1013.           }
  1014.       else if( used_fs == `ntfs )
  1015.           {
  1016.           ret = "ntfs";
  1017.           }
  1018.       }
  1019.       if( ret == "" ) ret = defaultv;
  1020.       y2milestone( "used_fs:%1 ret:%2", used_fs, ret );
  1021.       return ret;
  1022.   }
  1023.  
  1024.   global define list<string> GetNeededModules( symbol used_fs )``{
  1025.       list<string> ret = [];
  1026.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  1027.       if( used_fs==`ntfs && size(fsmap)==0 )
  1028.     {
  1029.     ret = ["ntfs"];
  1030.     }
  1031.       else
  1032.     {
  1033.     ret = fsmap[`needed_modules ]:[];
  1034.     }
  1035.       return ret;
  1036.   }
  1037.  
  1038.   global define string GetMakeFsType( symbol used_fs , string defaultv )``{
  1039.       map<symbol,any> fsmap     = GetFsMap( used_fs);
  1040.       string ret        = fsmap[`makefstype ]:"";
  1041.       if( ret == "" ) ret = defaultv;
  1042.       return ret;
  1043.   }
  1044.  
  1045.  
  1046.  
  1047.   /**
  1048.      * Load the kernel module which is necessary to mount a partition with used_fs!
  1049.      * @param used_fs filesystem
  1050.      * @return boolean
  1051.      * old load_fs_module
  1052.      */
  1053. global define boolean LoadModule( symbol used_fs )
  1054.     ``{
  1055.  
  1056.     list<string> all_needed_modules = GetNeededModules( used_fs );
  1057.     y2milestone("all needed modules for %1: %2", used_fs, all_needed_modules );
  1058.     boolean load_success = true;
  1059.  
  1060.     SCR::UnmountAgent (.proc.modules);
  1061.     map loaded_modules = (map) SCR::Read(.proc.modules);
  1062.     y2milestone( "loaded_modules %1", loaded_modules );
  1063.  
  1064.     foreach( string modulename, all_needed_modules,
  1065.     ``{
  1066.     if( modulename != "" &&  size (loaded_modules[modulename]:$[])==0 )
  1067.         {
  1068.         if( load_success )
  1069.         load_success = (boolean) SCR::Execute(.target.modprobe, modulename , "" );
  1070.  
  1071.         y2milestone ("Loaded fs module %1 %2", modulename, load_success?"Ok":"Failed");
  1072.         }
  1073.     });
  1074.     return load_success;
  1075.     };
  1076.  
  1077. global define integer MinFsSizeK( symbol fsys )
  1078.     ``{
  1079.     map<string,any> cap = capabilities[`unknown]:$[];
  1080.     cap = capabilities[fsys]:cap;
  1081.     integer ret = cap["min_fs_k"]:0;
  1082.     y2milestone( "MinFsSizeK fsys:%1 ret:%2", fsys, ret );
  1083.     return( ret );
  1084.     }
  1085.  
  1086. global define boolean MountUuid( symbol fsys )
  1087.     ``{
  1088.     map<string,any> cap = capabilities[`unknown]:$[];
  1089.     cap = capabilities[fsys]:cap;
  1090.     boolean ret = cap["uuid"]:false;
  1091.     y2milestone( "MountUuid fsys:%1 ret:%2", fsys, ret );
  1092.     return( ret );
  1093.     }
  1094.  
  1095. global define boolean MountLabel( symbol fsys )
  1096.     ``{
  1097.     map<string,any> cap = capabilities[`unknown]:$[];
  1098.     cap = capabilities[fsys]:cap;
  1099.     boolean ret = cap["label"]:false;
  1100.     y2milestone( "MountLabel fsys:%1 ret:%2", fsys, ret );
  1101.     return( ret );
  1102.     }
  1103.  
  1104. global define boolean ChangeLabelMounted( symbol fsys )
  1105.     ``{
  1106.     map<string,any> cap = capabilities[`unknown]:$[];
  1107.     cap = capabilities[fsys]:cap;
  1108.     boolean ret = cap["set_label_mount"]:false;
  1109.     y2milestone( "ChangeLabelMounted fsys:%1 ret:%2", fsys, ret );
  1110.     return( ret );
  1111.     }
  1112.  
  1113. global define integer LabelLength( symbol fsys )
  1114.     ``{
  1115.     map<string,any> cap = capabilities[`unknown]:$[];
  1116.     cap = capabilities[fsys]:cap;
  1117.     integer ret = cap["label_length"]:16;
  1118.     y2milestone( "LabelLength fsys:%1 ret:%2", fsys, ret );
  1119.     return( ret );
  1120.     }
  1121.  
  1122. global define map IsResizable( symbol fsys )
  1123.     ``{
  1124.     map<string,any> cap = capabilities[`unknown]:$[];
  1125.     cap = capabilities[fsys]:cap;
  1126.     map ret = $[];
  1127.     ret["extend"] = cap["extend"]:false;
  1128.     ret["shrink"] = cap["shrink"]:false;
  1129.     ret["mount_extend"] = cap["mount_extend"]:false;
  1130.     ret["mount_shrink"] = cap["mount_shrink"]:false;
  1131.     y2milestone( "IsResizable fsys:%1 ret:%2", fsys, ret );
  1132.     return( ret );
  1133.     };
  1134.  
  1135. global define symbol FsToSymbol( string type )
  1136.     ``{
  1137.     symbol return_value = `none;
  1138.     if( type == "ext2" )
  1139.       {
  1140.       return_value = `ext2;
  1141.       }
  1142.     else if( type == "ext3" )
  1143.       {
  1144.       return_value = `ext3;
  1145.       }
  1146.     else if( regexpmatch( type, "reiser.*" ) )
  1147.       {
  1148.       return_value = `reiser;
  1149.       }
  1150.     else if( type == "jfs" )
  1151.       {
  1152.       return_value = `jfs;
  1153.       }
  1154.     else if( type == "xfs" )
  1155.       {
  1156.       return_value = `xfs;
  1157.       }
  1158.     else if( type == "vfat" || regexpmatch( type, "fat.*" ))
  1159.       {
  1160.       return_value = `vfat;
  1161.       }
  1162.     else if( type == "ntfs" )
  1163.       {
  1164.       return_value = `ntfs;
  1165.       }
  1166.     else if( type == "hfs" )
  1167.       {
  1168.       return_value = `hfs;
  1169.       }
  1170.     else if( type == "swap" )
  1171.       {
  1172.       return_value = `swap;
  1173.       }
  1174.     return( return_value );
  1175.     }
  1176.  
  1177. global define boolean SetVolumeLabel( string dev, map part )
  1178.     ``{
  1179.     boolean ret = false;
  1180.     string cmd = "";
  1181.     symbol fs = part["used_fs"]:`unknown;
  1182.     string label = part["label"]:"";
  1183.     y2milestone( "SetVolumeLabel dev:%1 fs:%2 label:%3", dev, fs, label );
  1184.     if( fs == `ext2 || fs == `ext3 )
  1185.     {
  1186.     cmd = sformat("/sbin/tune2fs -L \"%1\" %2", label, dev );
  1187.     }
  1188.     else if( fs == `xfs )
  1189.     {
  1190.     if( size(label)==0 )
  1191.         label = "--";
  1192.     cmd = sformat("/usr/sbin/xfs_admin -L %1 %2", label, dev );
  1193.     }
  1194.     else if( fs == `reiser )
  1195.     {
  1196.     cmd = sformat("/sbin/reiserfstune -l \"%1\" %2", label, dev );
  1197.     }
  1198.     if( size(cmd)>0 )
  1199.     {
  1200.     y2milestone( "Excuting cmd:%1", cmd );
  1201.     ret = SCR::Execute(.target.bash, cmd ) == 0;
  1202.     // /sbin/reiserfstune always seems to return 1 even on success
  1203.     if( fs == `reiser )
  1204.         ret = true;
  1205.     }
  1206.     y2milestone( "SetVolumeLabel ret:%1", ret );
  1207.     return( ret );
  1208.     };
  1209.  
  1210. global define void DoChangedFsDefaults( map part )
  1211.     ``{
  1212.     string cmd = "";
  1213.     symbol fs = part["used_fs"]:`unknown;
  1214.     string dev = part["device"]:"";
  1215.     if( haskey( part, "loop_dev" ))
  1216.     {
  1217.     dev = part["loop_dev"]:"";
  1218.     }
  1219.     if( fs == `ext3 )
  1220.     {
  1221.     y2milestone( "dev:%1 fs:%2", dev, fs );
  1222.     cmd = sformat("/sbin/tune2fs -c %1 -i %2 %3", 500, "2m", dev );
  1223.     y2milestone( "Excuting cmd:%1", cmd );
  1224.     SCR::Execute(.target.bash, cmd );
  1225.     }
  1226.     };
  1227.  
  1228. global define boolean IsCryptMp( string mount, boolean prefix )
  1229.     ``{
  1230.     boolean ret = contains( crypt_m_points, mount );
  1231.     if( !ret && prefix )
  1232.     {
  1233.     list<string> mp = filter(string s, system_m_points, ``(s!="/") );
  1234.     foreach(string s, mp,
  1235.         ``{
  1236.         ret = ret || search( mount, s + "/" )==0;
  1237.         });
  1238.     }
  1239.     y2milestone( "IsCryptMp mount:%1 prefix:%2 ret:%3", mount, prefix, ret );
  1240.     return( ret );
  1241.     };
  1242.  
  1243. global define boolean IsSystemMp( string mount, boolean prefix )
  1244.     ``{
  1245.     boolean ret = contains( system_m_points, mount );
  1246.     if( !ret && prefix )
  1247.     {
  1248.     list<string> mp = filter(string s, system_m_points, ``(s!="/") );
  1249.     foreach(string s, mp,
  1250.         ``{
  1251.         ret = ret || search( mount, s + "/" )==0;
  1252.         });
  1253.     }
  1254.     if( size(mount)>0 )
  1255.     y2milestone( "IsSystemMp mount:%1 prefix:%2 ret:%3", mount, prefix, ret );
  1256.     return( ret );
  1257.     };
  1258.  
  1259. global define string RemoveCryptOpts( string opt )
  1260.     ``{
  1261.     string ret = opt;
  1262.     ret = String::CutRegexMatch( ret, ",*loop[^,]*", true );
  1263.     ret = String::CutRegexMatch( ret, ",*encryption=[^,]*", true );
  1264.     ret = String::CutRegexMatch( ret, ",*phash=[^,]*", true );
  1265.     ret = String::CutRegexMatch( ret, ",*itercountk=[^,]*", true );
  1266.     if( size(ret)!=size(opt) )
  1267.     {
  1268.     ret = String::CutRegexMatch( ret, "^,", false );
  1269.     y2milestone( "in %1 ret %2", opt, ret );
  1270.     }
  1271.     return( ret );
  1272.     };
  1273.  
  1274. map lenc = $[ "el" : "iso8859-7",
  1275.               "hu" : "iso8859-2",
  1276.           "cs" : "iso8859-2",
  1277.           "hr" : "iso8859-2",
  1278.           "sl" : "iso8859-2",
  1279.           "sk" : "iso8859-2",
  1280.           "en" : "iso8859-1",
  1281.           "tr" : "iso8859-9",
  1282.           "lt" : "iso8859-13",
  1283.           "bg" : "iso8859-5",
  1284.           "ru" : "iso8859-5"];
  1285.  
  1286. global define string LangTypicalEncoding()
  1287.     ``{
  1288.     string lang = Encoding::GetEncLang();
  1289.     string enc = "utf8";
  1290.     if( !Encoding::GetUtf8Lang() )
  1291.     {
  1292.     enc = "iso8859-15";
  1293.     lang = substring(lang, 0, 2);
  1294.     lang = tolower(lang);
  1295.     if( haskey( lenc, lang ) )
  1296.         {
  1297.         enc = lenc[lang]:"";
  1298.         }
  1299.     }
  1300.     y2milestone( "LangTypicalEncoding lang %1 ret %2", lang, enc );
  1301.     return( enc );
  1302.     }
  1303.  
  1304. global define string DefaultFstabOptions( map part )
  1305.     ``{
  1306.     symbol fsys = part["used_fs"]:`none;
  1307.     string fst_default = "";
  1308.     if( part["format"]:false && contains( [`ext2, `ext3, `reiser ], fsys ) )
  1309.     {
  1310.     fst_default = "acl,user_xattr";
  1311.     }
  1312.     else if( !Arch::ia64() && contains( [`vfat, `ntfs], fsys ) )
  1313.     {
  1314.     fst_default = "users,gid=users,umask=0002";
  1315.     string enc = LangTypicalEncoding();
  1316.     string code = Encoding::GetCodePage(enc); 
  1317.     if( size(enc)>0 )
  1318.         {
  1319.         if( fsys != `ntfs )
  1320.         { 
  1321.         if( enc=="utf8" )
  1322.             fst_default = fst_default + ",utf8=true";
  1323.         else
  1324.             fst_default = fst_default + ",iocharset=" + enc;
  1325.         }
  1326.         else
  1327.         fst_default = fst_default + ",nls=" + enc;
  1328.         }
  1329.     if( size(code)>0 && code != "437" && fsys!=`ntfs )
  1330.         {
  1331.         fst_default = fst_default + ",codepage=" + code;
  1332.         }
  1333.     if( fsys == `ntfs )
  1334.         {
  1335.         fst_default = "ro," + fst_default;
  1336.         }
  1337.     }
  1338.     y2milestone( "DefaultFstabOptions fsys %1 is %2", fsys, fst_default );
  1339.     return( fst_default );
  1340.     }
  1341.  
  1342. global define map DefaultFormatOptions( map part )
  1343.     ``{
  1344.     map ret = $[];
  1345.     symbol fsys = part["used_fs"]:`none;
  1346.     if( part["format"]:false )
  1347.     {
  1348.     if( fsys==`ext3 )
  1349.         {
  1350.         ret["opt_dir_index"] = $[ "option_str":"-O dir_index",
  1351.                                   "option_value":true ];
  1352.         }
  1353.     if( Arch::s390() && contains( [`ext2, `ext3], fsys ) ) 
  1354.         {
  1355.         ret["opt_blocksize"] = $[ "option_str":"-b",
  1356.                                   "option_value":"4096" ];
  1357.         }
  1358.     }
  1359.     y2milestone( "DefaultFormatOptions fsys %1 fmt %2 is %3", fsys, 
  1360.                  part["format"]:false, ret );
  1361.     return( ret );
  1362.     }
  1363.  
  1364. global define boolean HasFstabOption( map part, string opt, boolean prefix )
  1365.     {
  1366.     list<string> l = splitstring( part["fstopt"]:"", "," );
  1367.     if( prefix )
  1368.     l = filter( string s, l, ``(search(s,opt)==0));
  1369.     else
  1370.     l = filter( string s, l, ``(s==opt));
  1371.     y2milestone( "HasFstabOption fst:%1 opt:%2 prefix:%3 l:%4 ret:%5", 
  1372.                  part["fstopt"]:"", opt, prefix, l, size(l)>0 );
  1373.     return( size(l)>0 );
  1374.     }
  1375.  
  1376. global define map CheckFstabOptions( string option_list )
  1377.     ``{
  1378.     boolean found = false;
  1379.     integer index = 0;
  1380.     y2milestone( "CheckFstabOptions option_list=%1", option_list );
  1381.     list<string> olist = splitstring( option_list, "," );
  1382.     list<string> known = [];
  1383.     list<string> unknown = [];
  1384.     foreach( string o, olist,
  1385.     ``{
  1386.     if( contains( FstabOptionStrings, o ) )
  1387.         {
  1388.         known = add( known, o );
  1389.         }
  1390.     else 
  1391.         {
  1392.         found = false;
  1393.         index = 0;
  1394.         while( !found && index<size(FstabOptionRegex) )
  1395.         {
  1396.         found = regexpmatch( o, FstabOptionRegex[index]:"" );
  1397.         index = index + 1;
  1398.         }
  1399.         if( found )
  1400.         {
  1401.         known = add( known, o );
  1402.         }
  1403.         else
  1404.         {
  1405.         unknown = add( unknown, o );
  1406.         }
  1407.         }
  1408.     });
  1409.     map ret = $[  "all_known" : size(unknown)==0, 
  1410.                   "known_options" : mergestring( known, "," ),
  1411.                   "unknown_options" : mergestring( unknown, "," ) ];
  1412.     y2milestone( "CheckFstabOptions ret=%1", ret );
  1413.     return( ret );
  1414.     }
  1415.  
  1416. global define map GetFstabDefaultMap( string key )
  1417.     ``{
  1418.     return( FstabDefaultMap[key]:$[] );
  1419.     }
  1420.  
  1421. global define string GetFstabDefaultMntops( string key )
  1422.     ``{
  1423.     map m = GetFstabDefaultMap( key );
  1424.     return( m["mntops"]:"" );
  1425.     }
  1426.  
  1427. global define list GetFstabDefaultList( string key )
  1428.     ``{
  1429.     map m = GetFstabDefaultMap( key );
  1430.     return( [ m["spec"]:"", m["mount"]:"", m["vfstype"]:"", m["mntops"]:"",
  1431.               tostring(m["freq"]:0), tostring(m["passno"]:0) ] );
  1432.     }
  1433.  
  1434.  
  1435. }
  1436.