Lập trình C++ | Thao tác với input trong C++ (Advance)

mới xu được bên congdongcviet.com về việc nhập sai kiểu dữ liệu:http://forums.congdongcviet.com/showthread.php?t=6380

// that make basic console input easier for new C++ programmers.
// basic_input:
//    template<typename charT, typename traits, typename T>
//      inline bool basic_input(std::basic_istream<charT,traits>& is, T& x, charT delim)
//    template<typename charT, typename traits, typename Allocator>
//      inline bool basic_input(std::basic_istream<charT,traits>& is, std::basic_string<charT,traits,Allocator>& x, charT delim)
//    template<typename charT, typename traits>
//      inline bool basic_input(std::basic_istream<charT,traits>& is, charT* x, std::streamsize count, charT delim)
//    template<typename charT, typename traits, typename T>
//      inline bool basic_input(std::basic_istream<charT,traits>& is, T& x)
//  Returns:
//    bool – true if the input succeeded, false otherwise.
//  Effects:
//    This function attempts to read from the input stream into the passed in
//    variable up to the specified delimiter. If the data in the stream does
//    not match the expected format of the variable type, or if the character
//    following the data read in is not the delimiter, then the input fails.
//    On success, the variable x contains the inputted value. On failure, the
//    variable x is cleared (i.e. default-initialized).
//    On success or failure, the input stream is left in a good state and all
//    characters up to and including the delimiter are removed from the stream.
//    The delimiter defaults to ‘\n’ if not specified.
//    If the variable type is char* (or some other character pointer), and the
//    delimiter has not yet been reached prior to count characters being read
//    in, then the input has failed and the array pointed to by the char* will
//    be filled with count characters set to null.
//  Sample usage:
//    int i;
//    std::cout << “Enter an int: “;
//    while (!bip::basic_input(std::cin, i))
//        std::cout << “Invalid int! Try again: “;
// ignore_line:
//    template<typename charT, typename traits>
//    inline std::basic_istream<charT,traits>& ignore_line(std::basic_istream<charT,traits>& is, charT delim)
//    template<typename charT, typename traits>
//    inline std::basic_istream<charT,traits>& ignore_line(std::basic_istream<charT,traits>& is)
//  Returns:
//    std::basic_istream<charT,traits>& – the stream passed in.
//  Effects:
//    This function reads and discards all characters in the passed in input
//    stream up to and including the first instance of the delimiter. The
//    delimiter defaults to ‘\n’ if not specified.
//  Sample usage:
//    std::cout << “Press Enter to Close.\n”;
//    bip::ignore_line(std::cin);

#ifndef BASIC_INPUT_H_
#define BASIC_INPUT_H_

#include <istream>
#include <ios>
#include <string>
#include <limits>

namespace bip
template<typename charT, typename traits>
inline std::basic_istream<charT,traits>& ignore_line(std::basic_istream<charT,traits>& is, charT delim)
return is.ignore(std::numeric_limits<std::streamsize>::max(), delim);

template<typename charT, typename traits>
inline std::basic_istream<charT,traits>& ignore_line(std::basic_istream<charT,traits>& is)
return ignore_line(is, is.widen(‘\n’));

template<typename charT, typename traits, typename T>
inline bool basic_input(std::basic_istream<charT,traits>& is, T& x, charT delim)
std::ios::fmtflags old_flags = is.flags();
if ((is >> std::noskipws >> x) && (is.eof() || is.get() == delim))
return true;

x = T();
ignore_line(is, delim);
return false;

template<typename charT, typename traits, typename Allocator>
inline bool basic_input(std::basic_istream<charT,traits>& is, std::basic_string<charT,traits,Allocator>& x, charT delim)
if (std::getline(is, x, delim))
return true;

return false;

template<typename charT, typename traits>
inline bool basic_input(std::basic_istream<charT,traits>& is, charT* x, std::streamsize count, charT delim)
if (is.getline(x, count, delim))
return true;

if (is.gcount()+1 < count)
memset(x, charT(), count);

ignore_line(is, delim);
return false;

template<typename charT, typename traits, typename T>
inline bool basic_input(std::basic_istream<charT,traits>& is, T& x)
return basic_input(is, x, is.widen(‘\n’));
driver example
#endif  // BASIC_INPUT_H_

ví dụ:

#include <iostream>
#include <string>
#include “basic_input.h”

int main()
const std::streamsize cslen = 5;
char cstyle[cslen];
std::cout << “Enter a line of text: “;
if (bip::basic_input(std::cin, cstyle, cslen, ‘\n’))
std::cout << “The line of text read in was: ” << cstyle << std::endl;
std::cout << “Sorry, invalid: ” << cstyle << std::endl;

std::string s;
std::cout << “Enter a line of text: “;
bip::basic_input(std::cin, s);
std::cout << “The line of text read in was: ” << s << std::endl;

int i;
std::cout << “Enter an int: “;
if (bip::basic_input(std::cin, i))
std::cout << “The number read in was: ” << i << std::endl;
std::cout << “Sorry, invalid int!” << std::endl;

double d;
std::cout << “Enter a double: “;
while (!bip::basic_input(std::cin, d))
std::cout << “Invalid double! Try again: “;
std::cout << “The double read in was: ” << d << std::endl;

std::wstring ws;
std::wcout << L”Enter a line of text: “;
bip::basic_input(std::wcin, ws);
std::wcout << L”The line of text read in was: ” << ws << std::endl;

int wi;
std::wcout << L”Enter an int: “;
if (bip::basic_input(std::wcin, wi))
std::wcout << L”The number read in was: ” << wi << std::endl;
std::wcout << L”Sorry, invalid int!” << std::endl;

double wd;
std::wcout << L”Enter a double: “;
while (!bip::basic_input(std::wcin, wd))
std::wcout << L”Invalid double! Try again: “;
std::wcout << L”The double read in was: ” << wd << std::endl;

std::cout << “Press Enter to Close.\n”;


The Grub 2 Guide

The Grub 2 Guide
(formerly Grub 2 Basics)

According to the Release Notes, a Wubi upgrade to 10.10 from 10.04 fails and is still not recommended – “File not found”.
Bug # 613288
If you have upgraded to 10.10 and cannot boot normally:
Boot the LiveCD, make mount points and mount your Windows partition. Then mount your wubi installation. Note you must change sda1 to your Windows partition designation.

sudo mkdir /mnt/windows /mnt/wubi
sudo mount /dev/sda1 /mnt/windows
sudo mount -o loop /mnt/windows/ubuntu/disks/root.disk /mnt/wubi
gksu gedit +80 /mnt/wubi/boot/grub/grub.cfg

Remove all the lines above the first “menuentry” line (Approximately line 85). Save the file and then reboot. Do not run update-grub before rebooting.

Good News on Documentation
As of 2 July 2010 there is a new GNU Grub Manual. It is available on-line, as well as in HTML and PDF versions. It’s a step in making threads such as this unnecessary!

More Good News
As of late July 2010 grub-pc (1.98-1ubuntu7) will only display /, /boot, or /boot/grub partitions on which to install Grub 2. If running grub-install or dpkg-reconfigure grub-pc the user will no longer see every device and partition (including Windows). This should greatly reduce the chance of installing Grub 2 on a Windows system partition and making Windows unbootable. There will also be much less chance of installing Grub 2 to every existing partition.


Important Note to Wubi (Windows Ubuntu) Users: Grub Update results in “No Such Disk”:
A late July 2010 Grub 2 update is causing a “no such disk” error for some users of WUBI, resulting in an unbootable system. If the system doesn’t display the original Windows menu, the most likely cause of the failure is that Grub 2 was installed in the MBR and/or on the Windows partition. To correct this, restore the Windows bootloader using this link:
How to restore the Ubuntu/XP/Vista/7 bootloader

Whether the failure is due to improper user selections or Grub 2’s failure to recognize a Wubi install, it has been reported in the following bug and users can review it for status updates and recovery options when they become available:

“Fix Symbol ‘grub-puts’ Not Found” Error Message:
If you can get to a normal installation, run the grub-install command or use the “dpkg-reconfigure grub-pc” command to put Grub onto your current partition. If you have to use the Live CD, use chroot to run these commands (see chroot link in my signature line.

Note: Most of this information has been incorporated, with a few graphics, into a page in the Ubuntu Help site. I will try to keep this post up-to-date and users are free to continue to post comments here. The help page is located here: https://help.ubuntu.com/community/Grub2

  1. Introduction
  2. First Look Differences
  3. Improvements
  4. Booting Grub
  5. Grub 2 Files & Options
  6. Adding Entries to Grub 2
  7. Removing Entries from Grub 2
  8. Grub 2 Splash Images & Theming
  9. Changing Menu Resolution
  10. Password Protection
  11. Booting to Recovery Mode w/o Menu Option
  12. Uninstalling GRUB 2 > GRUB
  13. Reinstalling GRUB 2 from the LiveCD
  14. Booting to LiveCD ISO
  15. Booting from the Rescue Mode
  16. Restoring GRUB2 / XP / Vista / Win 7 Bootloaders
  17. Grub Rescue Image
  18. Selected Problems & Bugs
  19. Links

  1. Introduction
    I’ve written this guide to present some basic information about Grub 2. It is meant for users who may be familiar with basic editing of the original Grub (Grub Legacy) menu.lst and wonder how it carries over to Grub 2. The actual version of Grub 2 used in Ubuntu 9.10, Karmic Koala is 1.97~beta4; 1.98 is the Ubuntu 10.04, Lucid Lynx version. In keeping with Ubuntu’s “stable release” philosophy, 1.97~beta4 will remain the official version in 9.10/Karmic and will not be updated to 1.98. In this guide, any reference to Grub 2 will refer to the 10.04 Lucid Lynx 1.98 version, with major differences noted.

    Grub 2 will be the default in Ubuntu 9.10, Karmic Koala but the plan is not to convert over previous Grub legacy installations to Grub 2.
    Official Announcement / Story

    StartUp-Manager supports Grub 2, but not all options are available. The two most-used items, however, are: setting the default kernel/OS and setting the menu timeout delay. There are plans for a StartUp-Manager 2 that works only for Grub 2 but it is still under development according to its creator. To view a guide on installing and running StartUpManager, view the StartUpManager community doc or the forum post on which it was based: http://ubuntuforums.org/showthread.php?t=818177

    Official documentation at this point is still being created, which is partly the reason for this post. More comprehensive and complete documentation will hopefully be forthcoming from the developers and volunteers. Of the existing documentation, I have have provided several links to the better sources at the end of this post.

    For troubleshooting and modifying the Grub menu, it is important to know which version you are using (Grub legacy, 0.97; Grub 2 in Karmic 1.97~beta4; Grub 2 in Lucid 1.9. To confirm the version of Grub used in your system, run this command:

    grub-install -v

    Which should produce something like this:

    drs305@mycomputer:~$ grub-install -v
    grub-install (GNU GRUB 1.97~beta4)
  2. First Look Differences: GRUB vs GRUB 2
    At first boot, there will not be much difference in what the user sees on the boot menu. The one exception is a clean install of Ubuntu 9.10 with no other installed operating system. In this case, GRUB 2 will boot directly to the login prompt or Desktop without displaying a menu. Other major differences:

    • No ”/boot/grub/menu.lst”. It has been replaced by ”/boot/grub/grub.cfg”.
    • Hold down SHIFT to display the hidden menu during boot (formerly ESC is GRUB legacy).
    • There is no “find /boot/grub/stage1” at the grub prompt. Stage 1.5 has also been eliminated.
    • The main menu file, ”/boot/grub/grub.cfg” is not meant to be edited, even by ‘root’.
    • ”grub.cfg” is overwritten anytime there is a update, a kernel is added/removed or the user runs `update-grub` *
    • The user can use a custom file, ”/etc/grub.d/40_custom”, in which the user can place his own entries. This file will not be overwritten.
    • The primary configuration file for changing menu display settings is ”/etc/default/grub”.
    • There are multiple files for configuring the the menu – ”/etc/default/grub” mentioned above, and all the scripts in /etc/grub.d/ folder.
    • Other operating systems, such as Windows, should automatically be recognized and added to the menu.
    • No changes made in the configuration files will take effect until the `update-grub` command is also run.

    * To update the GRUB 2 menu, the command sudo update-grub will be used throughout this guide. update-grub actually runs the command “grub-mkconfig -o /boot/grub/grub.cfg” This runs several scripts and incorporates the results into /boot/grub/grub.cfg which detemines what is seen on the screen during boot. Since the GRUB 2 developers do not intend to remove the update-grub ‘stub’, it will be used for simplicity and ease of use.

  3. Improvements
    GRUB 2’s major improvements over the original GRUB include:

    • New configuration file structure
    • Scripting support including conditional statements and functions
    • Dynamic module loading
    • Rescue mode
    • Themes – under development
    • Graphical boot menu support and improved splash capability
    • Boot Ubuntu LiveCD and some other ISO images directly from hard drive
    • Non-X86 platform support (such as PowerPC)
    • Universal support for UUIDs (not just Ubuntu)
    • Improved internationalization, including support for non-ASCII characters
  4. Booting Grub
    Grub 2 loads before the operating system. It’s modular components are loaded on an as-needed basis. Menu display behavior is generally determined by settings in /etc/default/grub. Review the “Grub 2 Files & Options” section for specific entry and formatting guidance.

    The main options for displaying the menu are:

    • Initial Default
      • Grub 2 will boot straight into the default operating system if no other operating system is detected. No menu will be displayed. If another operating system is detected, the Grub 2 menu will display.
    • Timed display.
      • The default delay is 10 seconds. If no user input is made Grub 2 boots to the default entry.
      • The countdown can be stopped by pressing any key. The user must then make a selection manually.
      • The booted entry is determined by the DEFAULT= setting in /etc/default/grub, The first “menuentry” is 0.
    • Hidden
      • The user can interrupt the boot process and display the menu by holding down the SHIFT key until the menu displays. Grub 2 searches for a depressed SHIFT key signal during boot. If the key is pressed or Grub 2 cannot determine the status of the key, the menu is displayed. Note: The “SHIFT” keystatus check is currently nested within in a conditional statement within /etc/grub.d/30_os-prober and may not work under certain circumstances.
      • The time the screen remains blank but available for display is determined by a setting in /etc/default/grub.
      • To provide visual feedback during while the countdown continues, a countdown display can be shown on the screen.
      • At the end of the timeout, the default entry determined in /etc/default/grub will be selected.
    • Saved
      • If the default option is set to “saved”, the last kernel/system successfully booted will be selected and run if no input is made.
      • Unlike GRUB, GRUB 2 stores the “saved” entry as a string, not as a menu position number. In GRUB 2, the result is applied more consistently. Example: If the first entry (kernel -15) becomes the second entry due to a kernel update, it will still be the “saved” entry even though it’s position on the menu has changed.
  5. Grub 2 Files & Options
    Many of the files in /boot/grub will not be recognizable by users of Grub Legacy. Especially noticeable are the multitude of *.mod files. Grub 2 is modular and these files are loaded as necessary by the grub bootloader.

    The Grub 2 user-configurable settings are contained mainly in /etc/default/grub and the files in /etc/grub.d. When update-grub is executed the results are input into the /boot/grub/grub.cfg file.

    • /boot/grub/grub.cfg
      • This is the main Grub 2 file. It “replaces” Grub Legacy’s /boot/grub/menu.lst This file contains the Grub menu information but unlike Grub Legacy’s menu.lst file, grub.cfg is not meant to be edited.
        • grub.cfg is automatcially generated when “update-grub” is executed:
        • Each section (### BEGIN) is clearly delineated and references the file in the /etc/grub.d folder from which the information was generated.
        • grub.cfg is updated by running the “update-grub” or “update-grub” command as root.
        • By default, and whenever the “update-grub” command is executed, this file is made “read-only”. This is in keeping with the intent that the file should not be edited manually. If you must edit this file, instructions are provided in Section 2.
      • Sample grub.cfg including Windows and one manual entry (41_srcd):
        # It is automatically generated by /usr/sbin/grub-mkconfig using templates
        # from /etc/grub.d and settings from /etc/default/grub
        ### BEGIN /etc/grub.d/00_header ###
        if [ -s $prefix/grubenv ]; then
        set default="0"
        if [ ${prev_saved_entry} ]; then
          set saved_entry=${prev_saved_entry}
          save_env saved_entry
          set prev_saved_entry=
          save_env prev_saved_entry
          set boot_once=true
        function savedefault {
          if [ -z ${boot_once} ]; then
            save_env saved_entry
        function recordfail {
          set recordfail=1
          if [ -n ${have_grubenv} ]; then if [ -z ${boot_once} ]; then save_env recordfail; fi; fi
        insmod ext2
        set root='(hd0,1)'
        search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
        if loadfont /usr/share/grub/unicode.pf2 ; then
          set gfxmode=640x480
          insmod gfxterm
          insmod vbe
          if terminal_output gfxterm ; then true ; else
            # For backward compatibility with versions of terminal.mod that don't
            # understand terminal_output
            terminal gfxterm
        insmod ext2
        set root='(hd0,1)'
        search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
        set locale_dir=($root)/boot/grub/locale
        set lang=en
        insmod gettext
        if [ ${recordfail} = 1 ]; then
          set timeout=-1
          set timeout=10
        ### END /etc/grub.d/00_header ###
        ### BEGIN /etc/grub.d/05_debian_theme ###
        set menu_color_normal=white/black
        set menu_color_highlight=black/light-gray
        ### END /etc/grub.d/05_debian_theme ###
        ### BEGIN /etc/grub.d/10_linux ###
        menuentry 'Ubuntu, with Linux 2.6.32-16-generic' --class ubuntu --class gnu-linux --class gnu --class os {
            insmod ext2
            set root='(hd0,1)'
            search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
            linux    /boot/vmlinuz-2.6.32-16-generic root=UUID=444539ba-ab9e-4028-94f5-c1a86b5ec7c1 ro   quiet splash
            initrd    /boot/initrd.img-2.6.32-16-generic
        menuentry 'Ubuntu, with Linux 2.6.32-16-generic (recovery mode)' --class ubuntu --class gnu-linux --class gnu --class os {
            insmod ext2
            set root='(hd0,1)'
            search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
            echo    'Loading Linux 2.6.32-16-generic ...'
            linux    /boot/vmlinuz-2.6.32-16-generic root=UUID=444539ba-ab9e-4028-94f5-c1a86b5ec7c1 ro single 
            echo    'Loading initial ramdisk ...'
            initrd    /boot/initrd.img-2.6.32-16-generic
        menuentry 'Ubuntu, with Linux 2.6.32-14-generic' --class ubuntu --class gnu-linux --class gnu --class os {
            insmod ext2
            set root='(hd0,1)'
            search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
            linux    /boot/vmlinuz-2.6.32-14-generic root=UUID=444539ba-ab9e-4028-94f5-c1a86b5ec7c1 ro   quiet splash
            initrd    /boot/initrd.img-2.6.32-14-generic
        menuentry 'Ubuntu, with Linux 2.6.32-14-generic (recovery mode)' --class ubuntu --class gnu-linux --class gnu --class os {
            insmod ext2
            set root='(hd0,1)'
            search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
            echo    'Loading Linux 2.6.32-14-generic ...'
            linux    /boot/vmlinuz-2.6.32-14-generic root=UUID=444539ba-ab9e-4028-94f5-c1a86b5ec7c1 ro single 
            echo    'Loading initial ramdisk ...'
            initrd    /boot/initrd.img-2.6.32-14-generic
        ### END /etc/grub.d/10_linux ###
        ### BEGIN /etc/grub.d/20_memtest86+ ###
        menuentry "Memory test (memtest86+)" {
            insmod ext2
            set root='(hd0,1)'
            search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
            linux16    /boot/memtest86+.bin
        menuentry "Memory test (memtest86+, serial console 115200)" {
            insmod ext2
            set root='(hd0,1)'
            search --no-floppy --fs-uuid --set 444539ba-ab9e-4028-94f5-c1a86b5ec7c1
            linux16    /boot/memtest86+.bin console=ttyS0,115200n8
        ### END /etc/grub.d/20_memtest86+ ###
        ### BEGIN /etc/grub.d/30_os-prober ###
        menuentry "Microsoft Windows XP Home Edition (on /dev/sda1)" {
            set root=(hd0,1)
            chainloader +1
        ### END /etc/grub.d/30_os-prober ###
        ### BEGIN /etc/grub.d/40_custom ###
        menuentry "Jaunty 2.6.28-15-custom" {
            save_env saved_entry
            set root=(hd0,8)
            linux    /boot/vmlinuz-2.6.28-15-custom root=UUID=48e03255-22b3-488b-ae7e-9dbe4e2beac7 ro  quiet splash
            initrd    /boot/initrd.img-2.6.28-15-custom
        menuentry "SystemRescue" {
            save_env saved_entry
                set root=(hd0,6)
                linux   /sysrcd/rescuecd subdir=sysrcd setkmap=us
                initrd  /sysrcd/initram.igz
        ### END /etc/grub.d/40_custom ###
    • /etc/default/grub
      • This file contains information formerly contained in the upper section of Grub Legacy’s menu.lst and items contained on the end of the kernel line. The items in this file can be edited by a user with administrator (root) privileges.
        # If you change this file, run ‘update-grub’ afterwards to update
        # /boot/grub/grub.cfg.

        GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
        GRUB_CMDLINE_LINUX_DEFAULT=”quiet splash”

        # Uncomment to disable graphical terminal (grub-pc only)

        # The resolution used on graphical terminal
        # note that you can use only modes which your graphic card supports via VBE
        # you can see them in real GRUB with the command `vbeinfo’

        # Uncomment if you don’t want GRUB to pass “root=UUID=xxx” parameter to Linux

        # Uncomment to disable generation of recovery mode menu entries

        # Uncomment to get a beep at grub start
        #GRUB_INIT_TUNE=”480 440 1″

    • GRUB_DEFAULT – Sets the default menu entry. Entries may be numeric or “saved”
      • GRUB_DEFAULT=0 – Sets the default menu entry by menu position. As Grub Legacy, the first “menuentry” in grub.cfg is 0, the second is 1, etc.
      • GRUB_DEFAULT=saved – (Grub 1.98) Enables the “grub-reboot” and “grub-set-default” commands.
        • This setting allows the use of the following commands to set a default OS. The default OS will not be set merely by an interactive selection of an OS from the menu.
        • grub-set-default. Sets the default boot entry until changed.
          • The format is “sudo grub-set-default X, with X being the menuentry position (starting with 0 as the first entry) or the exact menu string. Examples: sudo grub-set-default 3 or sudo grub-set-default “Ubuntu, Linux 2.6.32-15-generic”
          • To obtain the existing menuentry choice number (starting from 0) or the menuentry “string”, run “grep menuentry /boot/grub/grub.cfg”
        • grub-reboot. This command sets the default boot entry for the next boot only. The format of the command is the same as for “grub-set-default” (see above).
        • For an example of how to enable the “saved” option with a custom menu, see the “Custom User Entries” section.
      • GRUB_DEFAULT=”xxxx” – An exact menu entry, including the quotation symbols, may also be used. In this case, location in the menu will not matter. Example: GRUB_DEFAULT=”Ubuntu, Linux 2.6.31-9-generic”
    • GRUB_SAVEDEFAULT=true * If set to true this setting will automatically set the last selected OS from the menu as the default OS on the next boot. No commands need be run to set the default OS. For this entry to work, the GRUB_DEFAULT entry should be set to saved.
    • GRUB_TIMEOUT=5 – No change from Grub Legacy. This is the number of seconds before the default entry is automatically booted.
      • Setting this value to -1 will cause the menu to display until the user makes a selection.
      • To display the menu on each boot use a value of 1 or higher.
      • This command defers to the GRUB_HIDDEN_TIMEOUT command. If the GRUB_HIDDEN_TIMEOUT option is interrupted by pressing the SHIFT key, the GRUB_TIMEOUT counter begins its countdown.
      • Caution: Holding down the “SHIFT” key will not display the menu if “GRUB_TIMEOUT=” is set to “0” .
      • In addition to editing the file as root, you can also run the following commands the check and change the default timeout value. The first checks the existing timeout, the second replaces the value. Replace T with the new value.
        cat /etc/default/grub | grep 'GRUB_TIMEOUT='   # Checks current TIMEOUT value.
        sudo sed 's/GRUB_TIMEOUT=5/GRUB_TIMEOUT=T/g' -i /etc/default/grub  # Change TIMEOUT value. Replace T with new value.
    • GRUB_HIDDEN_TIMEOUT=0 [ Note: This setting only applies to computers with only a single operating system. ]
      • The hidden timeout option allows a screen to be displayed without the Grub 2 menu, awaiting input from the user for a given number of seconds. It is available to single-OS computers – if multiple OS’s are known to Grub 2, this option is bypassed.
        On single-OS computers:

        • The menu will be hidden unless the user adds a # symbol to the beginning of this line ( # GRUB_HIDDEN_TIMEOUT=0 ) and the GRUB_TIMEOUT value is greater than 0.
        • If a background image is designated in 05_debian_theme it will be displayed rather than a blank screen during a hidden menu timeout.
        • For integers greater than 0:
          • The system will pause without displaying a menu for the designated number of seconds. If the user does not press the SHIFT key during the timeout the system will then boot the default OS/kernel.
          • If the user presses the SHIFT key to display the menu, the menu will be displayed for the number of seconds designated by the GRUB_TIMEOUT value unless the user again intervenes.
        • With a value of 0:
          • Unless the user intervenes, the system will boot the default OS/kernel with only a slight delay. No menu will be displayed.
          • The user may force displaying the menu as the computer boots by holding down the SHIFT key.

        On computers on which Grub 2 recognizes multiple OS’s:

        • This entry is ignored.
        • The menu will be displayed for the value designated in GRUB_TIMEOUT.
        • The hidden menu timeout option is not available, as it is bypassed by a conditional in /etc/grub.d/30_os-prober.
        • The system can still boot without displaying a menu by setting the GRUB_TIMEOUT value to 0, however a timeout delay with a blank screen is not available.
        • The keystatus check for SHIFT key usage is bypassed by the scripts. Holding down the SHIFT key during boot will not display the menu.
        • If the user of a multi-OS computer wishes to hide the menu while incorporating a blank screen timeout the scripts in /etc/grub.d/30_os-prober can be modified. Please refer to Grub 2 Title Tweaks.
      • true – No countdown is displayed. The screen will be blank.
      • false – A counter will display on a blank screen for the duration of the GRUB_HIDDEN_TIMEOUT value.
    • GRUB_DISTRIBUTOR=`lsb_release -i -s 2> /dev/null || echo Debian`
      • Determines the descriptive name in the menu entry. (Ubuntu, Xubuntu, Debian, etc.)
      If it exists, this line imports any entries to the end of the ‘linux’ command line (Grub Legacy’s “kernel” line) for both normal and recovery modes. This is similar to the “altoptions” line in menu.lst
    • GRUB_CMDLINE_LINUX_DEFAULT=”quiet splash”
      This line imports any entries to the end of the ‘linux’ line (Grub Legacy’s “kernel” line). The entries are appended to the end of the normal mode only. This is similar to the “defoptions” line in menu.lst. For a black screen with boot processes displayed in text, remove “quiet splash”. To see the grub splash image plus a condensed text output, use “splash”. This line is where other instructions, such as “acpi=off” are placed.

      For the GRUB_CMDLINE_LINUX_DEFAULT and GRUB_CMDLINE, quotation marks are required (single or double) if the entry is more than one alphanumeric entry. For example, quiet splash requires single or double quotes, while an entry such as quiet would not.

    • #GRUB_TERMINAL=console
      Uncomment to disable graphical terminal (grub-pc only). This can be useful if the user plans on spending a lot of time in the GRUB 2 command line mode. Scrolling and screen responsiveness will be greatly speeded up.
      Uncomment if you don’t want GRUB to pass “root=UUID=xxx” parameter to Linux
      Update: A bug requires quotation symbols be added for this option to be enabled. Change true to “true” and uncomment the line to eliminate UUIDs for linux entries.
    • #GRUB_GFXMODE=640×480
      You can add this line and remove the # symbol to make it active. This entry sets the resolution of the graphical menu (the menu text size). It provides resolutions supported by the user’s graphics card (e.g. 640×480, 800×600, 1280×1024, etc). The setting applies only to the boot menu text.
    • From the GRUB 2 menu you can display available resolutions by typing “c” and then at the “grub>” prompt type “vbeinfo”
      Add or uncomment this line to prevent “Recovery” mode kernel options from appearing in the menu. If you want a “Recovery” option for only one kernel, make a special entry in /etc/grub/40_custom.
    • GRUB_DISABLE_OS_PROBER=”true” * Enables/disables the os-prober check of other partitions for operating systems, including Windows, Linux, OSX and Hurd.
    • GRUB_INIT_TUNE=”480 440 1″
      • Introduced in Grub 1.98 (Lucid)
      • When uncommented, plays a single beep just prior to the Grub 2 menu display.
      • The format unless a file is named is: “tempo [pitch1 duration1] [pitch2 duration2] …”
      • The duration is based on the tempo. A tempo of 60 gives the duration a value of 1 second, 120 is .5, 240 is .25, 480 is .125, etc. The length of the tone can be changed by modifying either the tempo (all tones) or duration (individual tone).
        • Just a bit of fun:
          • Warning: The menu will not be displayed until the tone is finished
          • Close Encounters/5 Tone: GRUB_INIT_TUNE=”480 900 2 1000 2 800 2 400 2 600 3″
          • Fur Elise (note long): GRUB_INIT_TUNE=”480 420 1 400 1 420 1 400 1 420 1 315 1 370 1 335 1 282 3 180 1 215 1 282 1 315 3 213 1 262 1 315 1 335 3 213 1 420 1 400 1 420 1 400 1 420 1 315 1 370 1 335 1 282 3 180 1 215 1 282 1 315 3 213 1 330 1 315 1 282 3″
      • Online documentation is available by typing “info grub –index-search play” in a terminal.

      * Entries which are not found in the default file and must be added by the user.

    • /etc/grub.d/
      • The files in this folder are read during execution of “update-grub” or “update-grub” commands. The contents are imported into /boot/grub/grub.cfg

        The order of the entries in the grub menu is based on the order of the file names. File named with a starting numeral are run before those beginning with a letter. The order the files are run determines the menu order in grub.cfg.
        Custom entries can be added to the “40_custom” file or in a newly created file.

        Any file created must be executable in order to be included in the grub.cfg file during the “update-grub” command.

        • 00_header
        • 05_debian_theme: Set background and text colors, themes
        • 10_hurd Locates Hurd kernels
        • 10_linux Locates Linux kernels based on results of the “lsb_release” command.
        • 20_memtest86+: If the file /boot/memtest86+.bin exists, it is included as a menu item.
        • 30_os-prober: Searches for Linux and OS’s on other partitions and includes them in the menu.
        • 40_custom: A template for adding custom menu entries which will be inserted into grub.cfg upon execution of the “update-grub” command. This and any other custom file must be made executable to allow importation into grub.cfg.
  6. Adding Entries to Grub 2
    Menu entries can be added to grub.cfg automatically or manually.

    • Automatically.
      • When “update-grub” or “update-grub” is executed, Grub 2 will search for linux kernels and other Operating Systems. What and where is looks is based on the files contained in /etc/grub.d folder.
        • 10_linux searches for installed linux kernels on the same partition.
        • 30_os-prober searches for other operating systems.
    • Custom User Entries (/etc/grub.d/40_custom).
      • Entries to grub.cfg can be manually inserted by creating a file in the /etc/grub.d folder.
        • The name of the file determines the order in the menu. 30_os-prober entries will be placed before 40_custom entries, which will be placed before 50_my-sample entries.
        • Any created file must be made executable. This can be done as root by running “sudo chmod +x /etc/grub.d/filename“.
        • The files in the /etc/grub.d folder will be read and the contents included in grub.cfg when the “update-grub” command is executed as root.
      • A sample entry. This file creates a menu item for running the SystemRescueCD (previously installed) from a partition created on sda10. Folders and files must have been copied to the correct location in accordance with the SystemRescueCD if you wish to actually use this entry. Note this entry will not work for a SystemRescue ISO. See Section 14 for instructions on how to add an entry to boot ISO images.
        • Quote:
          exec tail -n +3 $0
          # This file provides an easy way to add custom menu entries. Simply type the
          # menu entries you want to add after this comment. Be careful not to change
          # the ‘exec tail’ line above.

          menuentry “System Rescue CD” {
          set root=(hd0,10)
          linux /sysrcd/rescuecd subdir=sysrcd setkmap=us
          initrd /sysrcd/initram.igz

        • Note the new partition naming convention. Devices start counting from “0” as done previously. sda is designated as “hd0”, sdb is “hd1”, etc. However the first partition is now designated as sda1. Counting partitions does not start with “0”. sda5 is “5”.
        • If the user wishes to get visual confirmation in the terminal that the 40_custom file contents are being added when “update-grub” is executed, the following line can be added to the /etc/grub.d/40_custom file:
          • Quote:
            echo “Adding 40_custom menu entries.” >&2
          • Place this line immediately after the first line – “#!/bin/bash” – and before the “exec tail -n +3 $0” line.
      • Tip: If you want to have your custom entries at the top of the menu (say you want custom titles), create a new file and name it “07_xxxx”. Since the files in /etc/grub.d/ are read sequentially, those in “07_custom” will be placed before those of “10_linux”. I recommend not naming a custom menu file lower than 06 so that any theme run from 05_debian_theme is allowed to run before any custom menu is created. After creating the file, run sudo update-grub and then check the value of “DEFAULT” in /etc/default/grub. If it doesn’t point to the correct menuentry, change the value of DEFAULT to the correct menuentry value.
      • Omitting memtest86+: To prevent “memtest86+” entries in your Grub 2 menu, remove the “executable” bit from /etc/grub.d/20_memtest86+. You can do this via a file browser by selecting “Properties (right click), Permissions”, or via the command line:
        sudo chmod -x /etc/grub.d/20_memtest86+
      • Omitting Recovery Mode entries: The file /etc/grub.d/10_linux was recently updated to include a check for recovery mode options. Edit /etc/default/grub and add or change this line:

        If you have an older version of /etc/grub.d/10_linux and the above does not work after updating grub, you can prevent “Recovery mode” entries in your Grub 2 menu, by editing /etc/grub.d/10_linux. If there are no conditional “if” statements concerning the recovery mode, place a comment symbol (#) in front of the following lines (at approximately line 146) of the old file:

        # linux_entry “${OS}, Linux ${version} (recovery mode)” \
        # “single ${GRUB_CMDLINE_LINUX}”

        If you wish to retain one “Recovery mode” entry for insurance, you can add an entry to /etc/grub.d/40_custom which will appear at the bottom of your grub menu.

      • Building a Totally Customized Menu: Ok, admit you are a control freak and you want to see only what you build yourself – customized titles, no “memtest86+” and no extra kernels. Here is how you do it:
        • Run sudo update-grub to get the current available kernels.
        • Copy the desired “menuentry” listings from /boot/grub/grub.cfg to /etc/grub.d/40_custom The entry begins with the line starting with “menuentry” and ends with a line containing “}”.
        • Add any other “menuentry” items you wish to see on the boot menu.
        • Edit the titles of the “menuentry” line if desired (between the quotation symbols). Do not change the lines following the “menuentry” line. Each entry should start with a “menuentry” line and end with a “}” on the last line.
        • Remove the executable bit from /etc/grub.d/10_linux, /etc/grub.d/20_memtest86+ and /etc/grub.d/30_os-prober
          Removing the executable bit from any file in /etc/grub.d will exclude the file from being included in grub updates.

          sudo chmod -x /etc/grub.d/10_linux /etc/grub.d/20_memtest86+ /etc/grub.d/30_os-prober
        • Run “sudo update-grub”
        • The updated /boot/grub/grub.cfg file should now contain only sections for “00_header”, “05_debian_theme” and “40_custom”.
        • The grub.cfg file will not be updated with the addition of a new kernel. To add a new kernel, make “10_linux” executable, run “sudo update-grub” to refresh the available kernels, and repeat these instructions.
      • Don’t forget to run “sudo update-grub” after making any changes to your /etc/grub.d files.
    • Manual Editing of grub.cfg (Not encouraged)
      Manual editing of /boot/grub/grub.cfg is not encouraged. Think of grub.cfg as a result, not as an initiator. The files that should be edited are contained in the /etc/grub.d folders and the /etc/default/grub file.

      In order to discourage its editing, grub.cfg is read-only. Even attempting to open, edit and save this file using root privileges cannot be done until the ‘read-only’ status is changed. If you must edit this file:

      sudo chmod +w /boot/grub/grub.cfg
      gksudo gedit /boot/grub/grub.cfg

      Note: This file is returned to ‘read-only’ status anytime the update-grub command is run.

  7. Removing Entries from Grub 2
    Entries should be removed by editing or removing files in the /etc/grub.d folder. The /boot/grub/grub.cfg file is read-only and should not normally require editing.

    • Automatically.
      • Too Many Kernels?
        • If you are not sure of the kernel you are currently using, in a terminal type “uname -r”.
        • Kernels removed via APT (Synaptic, “apt-get remove”, etc.) will automatically update grub.cfg and no user action is required. A great tool for removing kernels (and menu entries) is Ubuntu-Tweak, a safe and easy-to-use GUI app.
        • Many users keep one previous kernel known to work on the machine as a backup.
          • Synaptic
            • Type the kernel number in the search window at the upper right (for example – 2.6.28-11).
            • Find the “linux-image” and “linux-headers” files for the applicable kernel (example – linux-image-2.6.26-11 or “linux-image-2.6.26-11-generic).
            • Right click and select “Mark for Complete Removal” and then press the Apply main menu button.
            • The kernels will be removed from your system and from the Grub menu.
          • Ubuntu-Tweak
            • Go to the Ubuntu-Tweak download page.
            • Add the repository as per the instructions, or download the file manually and double-click the .deb file to install.
            • Ubuntu-Tweak will be available under Applications > System Tools.
            • To clean the kernels:
              • Select “Package Cleaner” on the left and “”Clean Kernel” from the right panel.
              • Press the “Unlock” button at the lower right, enter your password.
              • Select from the displayed list the kernel images and headers you wish to remove. The kernel in use is not listed.
              • Press the “Cleanup” button at the lower right to remove the selected kernel images and headers.
          • Too Many Operating Systems?
            • Other Operating Systems which have been removed from the computer will also be removed from the menu once “update-grub” is run as root.
            • Menu items are placed on the Grub2 menu by scripts. If you don’t want other Operating Systems to be entered in the menu, disable /etc/grub.d/30_osprober
              • Run this command to stop the script from running: sudo chmod -x /etc/grub.d/30_os-prober
              • DISABLE_30_OS-PROBER=’true’ in /etc/default/grub
          • Memtest86+
            • Code:
              sudo chmod -x /etc/grub.d/20_memtest86+
        • Run the update-grub command to allow the changes to be incorporated in grub.cfg
    • User-Created Entries.
      • To remove a user-created menu entry, remove the applicable file from the /etc/grub.d folder.
      • If a custom file contains multiple entries, individual items may be removed and others retained.
      • Once the file has been removed or edited, run “update-grub” to update grub.cfg.
  8. Grub 2 Splash Images & Theming
    Why reinvent the wheel? Visit this site for an excellent presentation on creating Grub 2 images:

    However, if encrypted disks are not an issue, here are the basics:

    • Manually copy grub splash images into the /usr/share/images/grub folder or install the default grub2 splash images via Synaptic or:
      sudo apt-get install grub2-splashimages
    • The grub2’s splash images are controlled by /etc/grub.d/05_debian_theme. Open this file for editing:
      gksudo gedit /etc/grub.d/05_debian_theme
      • Grub 1.97~beta4
        Find the following line and edit the highlighted area, replacing it with the grub splash image you wish to use (and located in /usr/share/images/grub):

        for i in {/boot/grub,/usr/share/images/grub}/moreblue-orbit-grub.{png,tga} ; do

        Note: There is a period ( . ) following the filename.

        • At one point Grub 2 splash images were downloaded and stored in /usr/share/images/desktop.base If this is where your grub images are stored, change the address in the previous command accordingly ( … /usr/share/images/desktop-base} … ).
      • Grub 1.97 (non-beta) & later)
        It’s a little easier to understand in Grub 1.97 (non-beta) and later versions of Grub. Find the following line and edit the highlighted area, replacing it with the path and grub splash image you wish to use:


        Example: WALLPAPER=”/home/my_username/grub_images/my_grubimage.png”

        • At one point Grub 2 splash images were downloaded and stored in /usr/share/images/desktop.base If this is where your grub images are stored, change the address in the previous command accordingly ( … /usr/share/images/desktop-base} … ).
    • Save the file, then update grub2:
      sudo update-grub

    A Note About Grub 2 Theming
    Theming is still under development in Grub 2. There are several different approaches being taken and users of Lucid have had success incorporating theming into their bootlaoder menus. For those interested in trying out the experimental theming possibilities, here are some references:
    GRUB2 theming for lucid? This thread has an excellent discussion about the state of theming in in bootloaders, as well as instructions on how to set it up as you get further into the thread. Both BURG and Grub 2 experimental are discussed.
    Grub 2 Experimental:
    http://grub.gibibit.com/ One method of introducing theming, when combined with this Launcpad PPA for Grub 2 experimental, Felix Zielcke’s PPA
    https://help.ubuntu.com/community/Burg and https://help.ubuntu.com/community/Burg

  9. Changing Menu Resolutions
    If the user wishes to change the resolution of the GRUB 2 screen while using a splash image follow these steps:

    1. Set the desired resolution in /etc/default/grub
      • Change the value of GRUB_GFXMODE= (Example: GRUB_GFXMODE=800×600)
        • If unsure of what resolutions are available to GRUB 2 they can be displayed by typing vbeinfo in the GRUB 2 command line. The command line is accessed by typing “c” when the main GRUB 2 menu screen is displayed.
    2. Select an image of the same size and make the change in /etc/grub.d/05_debian_theme
      • The image name is located in the line beginning with ” for i in {/boot”
      • If an image of the correct size is not used, the menu will not be positioned correctly.
      • Use the image editor of your choice to create/resize an image to the correct size.
      • The user may be able to view the image size via Properties in a file browser (check the Properties Image tab in Nautilus).
    3. Run update-grub as root to add the new settings to /boot/grub/grub.cfg
  10. Basic Password Protection

    Note: To reduce the size of this entry, a separate post with information on establishing Grub 2 password protection is located on the Ubuntu forums at: Grub 2 Password Protection and in the links at the bottom of this post.

    Grub 2 currently supports unencrypted password protection. Encrypted password protection using PBKDF2, as well as password scripting, is currently under development.

    Some of the major points regarding Grub 2 password protection:

    • Grub 2 has the ability to set password protection on individual menuentries and/or for specific users. Examples: Password protect Windows Recovery; prevent user2 from opening the Recovery mode.
    • If password protection is enabled, the superuser username and password are required to gain access to the Grub 2 command line and menu editing modes.
    • The username and/or password do not have to be the same as the Ubuntu logon name/password.
    • This is basic password security. The name/password are unencrypted; anyone having physical access to the machine and more than an elementary knowledge of how Linux works will be able to access the configuration files and bypass this feature.
    • Grub 2 password protection is still being developed. Encryption is available in experimental versions only. If password protection is used, recheck your scripts for changes whenever a new Grub 2 update is released. In 1.97~beta4, passwords must be assigned to each desired menu item. In Lucid Lynx, expect Grub 1.97 to password protect the entire Grub 2 menu if a superuser is designated.
  11. How to Boot to the Recovery Mode w/o a Menu Option
    1. If you have Grub 2 set to boot without displaying the menu at all, hold the SHIFT key down until the menu displays. (In Grub it was the ESC key.)
    2. Press any key once the menu is displayed to ‘freeze’ it. Then arrow to the kernel you want to boot.
    3. Press “e”
    4. Scroll to the end of the “linux /boot/vmlinuz….” line. If displayed, remove “quiet” and/or “splash”. Add the word “single” to the end of the line.
    5. Press CTRL-X to boot to the Recovery menu.
  12. Uninstalling GRUB 2
    The command line produces a cleaner uninstall and reinstallation. While adding and removing the packages can be accomplished with Synaptic, certain steps must be accomplished in a terminal.

    • Open a terminal: Applications, Accessories, Terminal.
    • Make backup copies of the main GRUB 2 folders & files
      • Code:
        sudo cp /etc/default/grub /etc/default/grub.old
        sudo cp -R /etc/grub.d /etc/grub.d.old
        sudo cp -R /boot/grub /boot/grub.old
    • Remove GRUB 2
      • Ensure you have an Internet connection and reliable power source. An interruption of either could leave your system in an unbootable condition.
      • Code:
        sudo apt-get purge grub-common grub-pc
      • The user will be warned the system will be unbootable without installing another bootloader.
      • Once the packages are removed, many files will still remain in ‘/boot/grub’
    • Install GRUB 2
      • Code:
        sudo apt-get install grub-common grub-pc
        • The user will be asked for any special commands to add to the default “linux” line. If you aren’t sure, leave it blank, press the TAB key to highlight “OK” and press ENTER.
        • Select the appropriate drive on which to install Grub2 (sda, sdb, etc) by highlighting the entry and pressing the space bar. Normally a partition (sda1, etc) should not be selected.
      • Code:
        sudo update-grub
      • Reboot
  13. Reinstalling GRUB 2 from LiveCD
    If you cannot boot from GRUB 2 and need to reinstall it, here is the simple method. For more details or for advanced options, refer to the Ubuntu community documentation here: Grub2 – Reinstalling GRUB 2:

    • Boot the Karmic or Lucid LiveCD (Try without installing).
    • From the Desktop, open a terminal – Applications, Accessories, Terminal.
    • Determine your normal system partition – `sudo fdisk -l` (That is a lowercase L)
    • If you aren’t sure, run `df -Th`. Look for the correct disk size and ext3 or ext4 format.
    • Mount your normal system partition:
      sudo mount /dev/sdXY /mnt
      • Example: sudo mount /dev/sda1 /mnt
      • Note: The partition to mount is normally the partition on which Ubuntu was installed: sda1, sdb5, etc. If you have a separate /boot partition, use the device on which the /boot partition is located. Grub 2 works best when installed in the MBR of the drive to which BIOS boots. Also remember that you mount the partition (including the number) in this step, but you do not include the partition number when you run the “sudo grub-install” command later.
      • Note: GRUB 2 counts the first drive (X) as “0”, but the first partition (Y) as “1”
    • Only if you have a separate boot partition:
      • Code:
        sudo mount /dev/sdXY /mnt/boot

        with sdXY being your /boot partition designation.

    • Reinstall GRUB 2:
      sudo grub-install --root-directory=/mnt /dev/sdX
      • Example: sudo grub-install –root-directory=/mnt /dev/sda
      • Note: Substitute the device on which Ubuntu was installed – sda, sdb, etc. Do not specify a partition number.
    • Unmount the partition *:
      sudo umount /mnt
      • * Note: If you mounted a separate /boot partition, unmount it first:
        sudo umount /mnt/boot
    • Reboot.
  14. Booting LiveCD and Other ISOs
    Grub 2 provides the capability to boot certain .iso images. These image files (ISO’s) include the Ubuntu LiveCDs, SystemrescueCD and the Parted Magic CD.

    The following examples assume the ISO image is located on the user “drs305″‘s Desktop on sda1. The address of the file, named test.iso would be /home/drs305/Desktop/test.iso. Grub 2 uses the convention (hd0,1) to designate sda1. The user must change the path and filenames in the following examples to match the location of the ISO image on their system.

    In order to incorporate an ISO boot option into the Grub2 menu, take the following steps:

    • Open the /etc/grub.d/40_custom file for editing as root, or create another custom file in the same folder.
    • Create a menuentry. Leave the existing first 5 lines of the file alone. Any entries should be made below the pre-existing lines.
    • Make sure the partition, path and filename are correct for the image you will be using.
    • Ensure there are no spaces at the end of any lines.
    • Save the file, run “sudo update-grub”, and then check the contents of /boot/grub/grub.cfg to make sure the contents of the 40_custom file are included. The user will not see the custom file listed in the terminal during the running of the update-grub command.

    The following are examples of an Ubuntu LiveCD, the SystemRescueCD, and the Parted Magic CD. In the examples, the ISO images are stored on user “drs305″‘s Desktop on sda1. These entries would be added to the /etc/grub.d/40_custom file.

    • For the SystemRescue CD, replace “rescuecd with “rescue64” on 64-bit systems.
    • The “quiet” option has been omitted from the “linux” line in order for the user to see progress during boot. Even so, there may be periods where the boot appears to halt. Let it continue unless an error message is visible.
    menuentry "Lucid ISO on /dev/sda1" {
    loopback loop (hd0,1)/home/drs305/Desktop/ubuntu-10.04-beta2-desktop-amd64.iso
    linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=/home/drs305/Desktop/ubuntu-10.04-beta2-desktop-amd64.iso noprompt 
    initrd (loop)/casper/initrd.lz
    menuentry "  SystemRescue-ISO on /dev/sda1" {
    loopback loop (hd1,5)/home/drs305/Desktop/systemrescuecd-x86-1.5.1.iso
    linux (loop)/isolinux/rescuecd setkmap=us isoloop=/home/drs305Desktop/systemrescuecd-x86-1.5.1.iso
    initrd (loop)/isolinux/initram.igz
    menuentry "Test Parted Magic ISO on /dev/sda1" {
    set root=(hd0,1)
    loopback loop (hd0,1)/home/drs305/Desktop/pmagic-4.10.iso
    linux (loop)/pmagic/bzImage iso_filename=/home/drs305/Desktop/pmagic-4.10.iso boot=live load_ramdisk=1 prompt_ramdisk=0 noeject noprompt 
    initrd (loop)/pmagic/initramfs
  15. Booting from the Rescue Mode
    Here are some things to keep in mind regarding the rescue mode.

    • Use the “set” command to review the current rescue mode settings.
    • Use “ls” to see the partitions. You must determine the Ubuntu partition.
    • Use “ls (hdX,Y)/boot” to inspect the partition you think is the Ubuntu partition. If you find the correct partition, it will show files and the grub folder. (Example: ls (hd0,5)/boot )
    • Use “set prefix=(hdX,Y)/boot/grub to set the correct path to the grub folder. This must be correct before you can use rescue commands or load the kernel.
    • set root=(hdX,Y) X is the device/drive, starting with 0. Y is the partition, starting with 1. (Example: (hd0,1) is sda1. (hd3,5) is sdc5.
      • For Wubi installs, use: set root=(loop0)
    • You must load modules before you can use them, and the prefix path must be correct.
    • If an unknown command or file not found error message is generated, the path in the prefix is incorrect or the module is not loaded.
    • insmod normal help linux – Loads the normal, help, linuxmodules. If they load there is no terminal message. Additional modules may be loaded in the same manner.
    • linux /vmlinuz root=/dev/sdXY ro – Load the linux kernel, substituting the correct designations for “X” and “Y” (example: sda1). The user will see a message showing the kernel has been loaded. (See graphic above)
      • Note: For Wubi installs within Windows, use this code: linux /vmlinuz root=/dev/sdXY loop=/ubuntu/disks/root.disk ro
    • initrd /initrd.img Load the initrd image. When pressing enter, the user may or may not see a message in the terminal. (See highlighted graphic above)
    • boot

    More information on the rescue mode is available in the Command Line & Rescue Mode section of the Ubuntu Grub 2 community doc.

  16. Restoring GRUB2 / XP / Vista / Win 7 Bootloaders
    talsemgeest has written an excellent guide on how to restore the bootloaders of various operating systems following the installation of another one. Make sure you reference the section for “9.10 and Beyond”, which is for GRUB 2.

    Rather than duplicate his efforts in this post, here is the link to the original:

    Restoring Windows MBR without a Windows CD
    If you want to boot directly to Windows but Grub has overwritten the MBR, the normal procdeure is to use the Windows CD to restore things. If you do not have access to the Windows CD, the following commands will rewrite the MBR, removing Grub and allowing the system to boot directly into Windows.

    Boot the Ubuntu LiveCD, open a terminal (Applications, Accessories, Terminal) and enter the following commands. Make sure you correctly identify the Windows device (normally sda):

    sudo apt-get install lilo
    sudo lilo -M /dev/sda mbr

    Bonus Section: BSD Menuentry – If you need to have an entry to boot into BSD/Windows from the Grub2 menu, here is the menuentry to put into a custom file:

    menuentry “FreeBSD” {
    insmod ufs2
    set root=(hd1,1)
    chainloader +1
  17. Grub Rescue Image
    A bootable Grub 2 rescue image is available for both floppies and CDs. To obtain the images, install “grub-rescue-pc”. Once installed, three images are available in /usr/lib/grub-mkrescue. Use the I]grub-mkrescue [/I] command to create the rescue ISO. See the MAN page for more information. Note: A customized rescue ISO only uses the current systems Grub 2 /boot/grub files. No information from /etc/grub.d or /etc/default/grub is imported.

    The ISO only boots to the grub prompt. It uses the Grub 2 files found on the ISO; if the problem is with the system’s Grub 2 files the rescue ISO should boot. However, the ISO contains no kernels and must be told where to find the correct kernel and initrd files on the system. The user must know the drive/partition on which the boot files are located and the non-Grub files must exist and be uncorrupted.

    If the user hasn’t made a rescue floppy/ISO, other alternatives include the Ubuntu Installation/LiveCD or SuperGrub Disk.

    • grub-rescue-floppy.img – For floppy images.
      • To Install:
      • Insert a disk in the floppy drive.
      • Code:
        fdformat /dev/fd0
        mkfs -t msdos /dev/fd0
        dd if=/usr/lib/grub-rescue/grub-rescue-floppy.img of=/dev/fd0
    • grub-rescue-cdrom.iso – When burning the image to a CD, select the option to copy an image and not the files.
      • Generate the image using the following command:
        • Code:
          grub-mkrescue --output=<path/filename>
      • If an error message “/usr/bin/grub-mkrescue: 324: xorriso: not found”, install the xorriso package and rerun the command.
      • Copy the ISO image to a CD using the CD burning app of your choice.

    Once the grub rescue floppy/CD boots to the grub prompt, run the following commands.

    The commands are slightly different than those used for booting by other means. The Grub 2 files on the floppy/CD are used, and only the kernel and initrd.img files need to be loaded.

    Command line tips:

    • Drives start counting at 0 (sda=0, sdb=1, etc). Partitions start counting at 1 (1=1, etc). Substitute the correct drive letter for X, correct number for Y, and substitute the correct numbers for (hd0,1).
    • You must type the entire path and kernel and initrd names if (hdX,Y)/vmlinuz and (hdX,Y)/initrd.img do not exist. You can check by running this command:
      • ls (hdX,Y)/

      If vmlinuz and initrd.img do not exist at (hdX,Y)/, you can simplify the typing using the TAB complete feature.

    • On the linux line, type “vml” and then TAB to help complete the kernel number. Ensure the complete kernel name is entered. Be sure to fill the kernel number completely, and don’t forget the “root=” and “ro” sections of the linux line.
    • On the initrd line, type “ini” and TAB to fill in a large part of the name. Continue typing/TABBING to ensure the complete .img name is used.
    • Sections in bold should be changed to match the user’s system.
    set root=(hd0,1)
    linux (hdX,Y)/vmlinuz root=/dev/sdXY ro
    # or if (hdX,Y)/vmlinuz does not exist:
    linux (hdX,Y)/boot/vmlinuz- root=/dev/sdXY ro
    # then
    initrd (hdX,Y)/boot/initrd.img 
    # or if (hdX,Y)/initrd.img does not exist:
    initrd (hdX,Y)/boot/initrd.img-2.6.33-25-generic 
  18. Selected Problems & Bugs

    meierfra has been busily building pages which detail how to solve many of the common problems users are experiencing with Grub 2. His SourceForge web page should be one of the first stops for those seeking answers to Grub 2 issues.

    Wubi (Windows Ubuntu) Users – wubildr
    Grub2 updates in the spring of 2010 triggered a bug in the ntfs module causing Wubi boot failures. The solution to this boot problem was posted by Agostino Russo and is found in this Lucid Lynx LaunchPad Bug Report #477169, Post 210. The module causing the errors has been fixed and replacing the “wubildr” file in Windows permanently solves this problem. meierfra has kindly provided clear instructions on how to fix this problem at http://sourceforge.net/apps/mediawik…lems:Wubi_9.10

    “Fix symbol ‘grub_puts’ not found” Error. After Upgrading from Karmic to Lucid
    BIOS and the Grub2 device map may no longer agree. See this post:

    Lose Ubuntu/Windows After Installing the Other
    If you have lost the ability to boot into Windows or Ubuntu following the installation/reinstallation of the other OS it could be an overwritten MBR issue. If the OS was previously working, there is an excellent guide written by talsemgeest that may very well restore the lost OS. Here is the link:
    How to restore the Ubuntu/XP/Vista/7 bootloader (Updated for Ubuntu 9.10)

    No Menu On Initial Boot
    If you are already on the Ubuntu Desktop, run “sudo update-grub”. This may detect additional operating systems, which may allow the Grub menu to be displayed on the next boot. Otherwise:
    Open /etc/default/grub:

    gksu /etc/default/grub

    Disable the “GRUB_HIDDEN_TIMEOUT=” line by placing a # symbol at the beginning of the line.
    Set “GRUB_TIMEOUT=” to a positive integer (number of seconds to display the menu before automatic selection) or “-1” to wait for the user to press ENTER (no timeout). The entry will look like this:


    Save the file, update grub (“sudo update-grub”) and reboot.

    External Drive Installs – Bug bug/496435
    Installs of Ubuntu on external drives can cause problems as grub-install uses device names (e.g. sda, sdb) rather than UUIDs in certain circumstances. If connected to another machine when an update of grub-pc is made, the upgrade may be written to the incorrect device and make the computer unbootable.

    A workaround is posted on the bug link above.

    External Drive Installs and MBR – Bug bug/414996
    When installing Ubuntu to a USB drive, the potential exists for GRUB 2 to write to the hard drive’s MBR or split the installation between the hard drive and the USB drive (rather than completely on the USB device). This can render the main drive unbootable.

    Workaround: During the final stages of the install there is an “Advanced” button which allows the user to select the install location.

    HP Machines Fails to Load Grub after Using Windows – Bug [URL=”https://bugs.launchpad.net/ubuntu/+source/grub2/+bug/441941″%5Dbug/441941/URL%5D
    After installing Grub 2 on a HP machine, the system boots normally until the first time it’s booted into Windows. On the next boot, the system hangs at “Grub loading”.

    Workaround: HP protection tools are rewriting to the MBR when Windows is run. The protecttools app must be removed/disabled. Refer to post #10 in the Bug Report.

    VGA Deprecated” Message on Boot
    Symptom: A blank screen appears with a message concerning VGA being deprecated after the menu item is selected (manually or by default). The message will be a variation of: “VGA=792 is deprecated. Use set GFX payload=1024x768x24, 1024×768 using the linux command instead.”

    The message probably is informing the user that there is a vga entry on either the “GRUB_CMDLINE_LINUX_DEFAULT=” or “GRUB_CMDLINE_LINUX=” line of /etc/default/grub. “Deprecated” means that there is a newer, preferred way to convey this instruction in GRUB 2. (Note the “vga=” method will still work, despite the message. It is advisory only.)

    In the example above, the line would probably look something like:

    GRUB_CMDLINE_LINUX_DEFAULT=quiet splash vga=792″

    To conform to the desired format and eliminate the message, change the above lines in /etc/default/grub to look like the following, using the “vga” value, and translated value, found in your current default file:


    Save the file and run “sudo update-grub” for the changes to be incorporated in the menu.
    There is a vga conversion table located at: http://wiki.archlinux.org/index.php/Gensplash From the GRUB 2 command line, you can run “vbeinfo” to see resolutions supported by your system.

    File Not Found (From a Grub 2 prompt)
    Not to be confused with the Grub Legacy “File Not Found – Error 15” (See next).
    When this message appears in Grub 2, it means that G2 cannot find one or more of the files required to accomplish the task. If this occurs, the user can use the “ls” command to find out what drives/partitions G2 sees. The output normally is something like (hd0) (hd0,1) (hd0,2) (hd0,5) (hd1) (hd0,1), etc. Remember the first drive (X) is “0”, the first partition (Y) is “1”. You can then inspect the contents, checking for the proper files with /boot, with “ls (hdX,Y)/boot”, for instance.

    Often in this case the user must reset “root” and/or “prefix”. You can see the current settings from the G2 command line with the command “set”. If you know the device/partition you want to boot, from the Grub 2 terminal run the following. You will get no feedback if there isn’t an error. You can check the results by running “set” again.

    set root=(hdX,Y)                    # Example:  set root=(hd0,5)
    set prefix=(hdX,Y)/boot/grub        # Example for a normal Ubuntu install on sda1: set prefix=(hd0,1)/boot/grub

    error: no such device: 86d32ee3-aec6-490b-8dab-e5cfff9c7af9
    This error is the result of a failure of the GRUB 2 search function. There are various bugs associated with the search function. At the Grub2 menu, highlight the OS you want to boot. Press “e” to edit the menuentry. Delete the entire “search …” line, then CTRL-x to boot.

    If the above does not solve the problem, hightlight the OS you want to boot, press “e” to enter the grub edit mode, and on the line beginning with “linux /” change the section “root=UUID…” to “root=/dev/sdXY …” with sdXY being the drive and partition on which the system is installed.

    Once you have booted into the system, you will modify the /usr/lib/grub/grub-mkconfig_lib file in accordance with this link:
    Boot Problems:search

    File Not Found (Error 15)
    This error is the result of a GRUB 2 installation to /boot but a Master Boot Record ( MBR ) which still contains Grub legacy. This can happen if you don’t select your drive when running sudo upgrade-from-grub-legacy. Shortly after starting this command the user will be asked to select the device (sda, sdb, etc). Highlight the drive and press the space bar to select it when presented with this screen. Failure to select a drive will result in an Error 15.

    To recover from this error, GRUB 2 must be reinstalled. Go to the community documentation File Not Found (Error 15) for instructions.

    If you find you need to remove the following lines manually to get Grub to boot properly:

    save_env recordfail

    Open /etc/grub.d/10_linux with admin rights:

    gksu gedit /etc/grub.d/10_linux

    Look for this section and comment the lines in bold;

    linux_entry ()
    menuentry “$1” {
    save_env recordfail

    Change it to:

    – linux_entry ()
    menuentry “$1” {
    # recordfail=1
    # save_env recordfail

    Save the file, then run

    sudo update-grub

    The two lines should no longer appear when you press E to view the selection in the Grub 2 menu. You will see a “save_env save_entry” line but this should not cause the failure if you successfully booted the previous time.

    Grub 2 Hangs 10-30 Seconds between Grub 2 Loading and Menu Display.
    This is a known bug that can be caused by GRUB 2 and /boot being loaded on different partitions. To fix the problem, run

    sudo dpkg-reconfigure grub-pc

    Select to load Grub 2 on the same device as the /boot partition. In your system BIOS, change the drive to boot from first to the drive with the /boot partition.

    Wubi Installs within Windows Won’t Boot.
    This bug has been fixed in Ubuntu 10.04. For prior versions, the user is greeted with “Try (hd0,0) : NTFS5: ” This is a known bug as well as others that may cause Wubi boot failures. Refer to meierfra’s Boot_Problems:Wubi_9.10 page.

    “Grub loading. The symbol ‘ ‘ not found. Aborted.” on Dell machines..
    On Dell computers with Dell DataSafe Local Backup (DDSLB) installed, the above message is displayed with a series of characters within the ‘ ‘ section. This is a reported bug,
    bug #482757. Thanks to merry_meercat’s post which details how to fix the problem.

    “error: the symbol `grub_xputs` not found”.
    Use the Live CD to chroot into your Ubuntu partition and purge/reinstall Grub2. See post #5 here:

    Grub “error: out of disk” or “failed to boot default entries”.
    This error message is sometimes generated when Grub 2 cannot properly write to the file /boot/grub/grubenv. Refer to meierfra’s Boot_Problems:Write page.

    “Grub loading. The symbol ‘ ‘ not found. Aborted.” on Dell machines..
    On Dell computers with Dell DataSafe Local Backup (DDSLB) installed, the above message is displayed with a series of characters within the ‘ ‘ section. This is a reported bug,
    bug #482757. Thanks to merry_meercat’s post which details how to fix the problem.

Hướng dẫn sử dụng VMWare Workstation (Máy ảo)


ANh em nào học mạng chắc hẳn đệu biết tới máy ảo ! VMWare là một chuơng trình máy ảo rất phổ biến và được sử dụng rộng rãi ! Và cách sử dụng nó ư ! Sau đây các bạn sẽ biết sử dụng thui !

1. Các tiện ích của VMware:
VMware giúp giả lập máy tính ảo trên một máy tính thật. Khi cài đặt VMware lên, ta có thể tạo nên các máy ảo chia sẻ CPU, RAM, Card mạng với máy tính thật. Điều này cho phép xây dựng nên một hệ thống với một vài máy tính được nối với nhau theo một mô hình nhất định, người sử dụng có thể tạo nên hệ thống của riêng mình, cấu hình theo yêu cầu của bài học.
2. Cách tạo nên các máy ảo từ VMware:
Để sử dụng VMware đầu tiên chúng ta cần tạo nên một máy ảo, nơi mà chúng ta sẽ dùng để cài đặt nên các hệ điều hành. Chúng ta có thể tuỳ chọn dung lượng ổ cứng, dung lượng RAM, cách kết nối mạng của máy ảo… Việc tiếp theo cần làm là cài đặt nên một hệ điều hành trên máy ảo đó. Hiện tại, VMware hỗ trợ cài đặt rất nhiều dạng hệ điều hành. Chúng ta có thể cài các phiên bản của Windows, Linux, Unix… trên các máy ảo VMware. Việc cài đặt hệ điều hành trên máy ảo hoàn toàn tương tự như cách cài đặt trên các máy thật.
3. Chia sẻ tài nguyên của các máy ảo:
a- Chia sẻ CPU và RAM: Các máy ảo sẽ chia sẻ CPU và RAM của máy tính thật. Để đảm bảo hệ thống có thể chạy tốt, yêu cầu máy tính thật phải có cấu hình tương đối cao, khoảng 1GB RAM để có thể chạy đồng thời 4, 5 máy ảo.

Hình 1: Thay đổi dung lượng của RAM

b- Chia sẻ ổ cứng: Khi tạo ra các máy ảo, chúng ta sẽ tạo ra một ổ cứng dành riêng cho máy ảo nằm trên máy thật. Ổ cứng ảo này được tạo trên vùng đĩa trống của ổ đĩa thật, do đó không ảnh hưởng đến các dữ liệu đang có trên ổ đĩa thật. Chúng ta có thể tuỳ chọn dung lượng của ổ cứng này, có thể ấn định ngay dung lượng hoặc cũng có thể để dung lượng của ổ cứng này là động, sẽ thay đổi tuỳ theo quá trình sử dụng của chúng ta sau này.

Hình 2: Tùy chọn dung lượng đĩa cứng

c- Chia sẻ card mạng: Sau khi cài đặt lên, VMware sẻ tạo nên 2 card mạng VMware 1 và VMware 8 trên máy thật và máy thật có thể sử dụng 2 card mạng này để kết nối với các máy ảo. Khi lựa chọn cấu hình mạng cho các máy ảo, ta có thể chọn một trong các chế độ sau:

Hình 3: Chọn lựa cấu hình mạng

Bridged networking: Card mạng của máy ảo sẽ được gắn trực tiếp với card mạng của máy thật (sử dụng switch ảo VMnet0). Lúc này, máy ảo sẽ đóng vai trò như một máy trong mạng thật, có thể nhận DHCP từ mạng ngoài, hoặc đặt IP tĩnh cùng dải với mạng ngoài để giao tiếp với các máy ngoài mạng hoặc lên Internet.

Hình 4: Cấu trúc mạng Bridged Networking

NAT: Máy ảo được cấu hình NAT sẽ sử dụng IP của máy thật để giao tiếp với mạng ngoài. Các máy ảo được cấp địa chỉ IP nhờ một DHCP ảo của VMware. Lúc này, các máy ảo sẽ kết nối với máy thật qua switch ảo VMnet8, và máy thật sẽ đóng vai trò NAT server cho các máy ảo.

Hình 5: Cấu trúc mạng NAT

Host-only Networking: Khi cấu hình máy ảo sử dụng host-only networking, máy ảo sẽ được kết nối với máy thật trong một mạng riêng thông qua Switch ảo VMnet1. Địa chỉ của máy ảo và máy thật trong mạng host-only có thể được cấp bởi DHCP ảo gắn liền với Switch ảo Vmnet1 hoặc có thể đặt địa chỉ IP tĩnh cùng dải để kết nối với nhau.

Hình 6: Cấu trúc mạng Host-Only

Ngoài các kết nối trên, ta có thể sử dụng các switch ảo trong VMware để kết nối các máy ảo thành một hệ thống như mong muốn. Khi cài đặt lên, VMware tạo sẵn cho chúng ta 10 Switch ảo từ VMnet0 đến VMnet9. Ngoài các Switch ảo VMnet0 (dùng cho mạng Bridged Networking), VMnet8 (dùng cho mạng Nat Networking) và VMnet1 (dùng cho mạng Host-Only Networking), chúng ta còn 7 Switch ảo khác để thực hiện việc kết nối các máy ảo. Chúng ta có thể đặt IP động trên các máy nối với các Switch này để nhận DHCP ảo, hoặc có thể đặt IP tĩnh cùng dải cho các máy này đảm bảo chúng kết nối được với nhau.

Hình 7: Các tùy chọn kết nối mạng cho máy ảo

d- Chia sẻ ổ đĩa CD-ROM: Các máy ảo có thể sử dụng ổ CD-ROM của máy thật. Ngoài ra, ta có thể dùng một file ISO để đưa vào ổ CD-ROM của máy ảo, lúc này máy ảo sẽ nhận file ISO giống như một đĩa CD-ROM trong ổ đĩa của mình.

Hình 8: Tùy chọn dạng ổ CD-ROM

4. Sử dụng Snapshot
Snapshot một máy ảo cho phép ta lưu lại trạng thái của máy ảo tại thời điểm đó. Snapshot sẽ lưu lại thông tin về ổ cứng, Ram và các Setting trên máy ảo. Sau khi lưu snapshot, chúng ta có thể quay trở lại trạng thái của máy ảo bất cứ lúc nào. VMware cho phép chúng ta lưu nhiều snapshot của máy ảo, vì thế người dùng có thể sử dụng một máy ảo vào nhiều ngữ cảnh khác nhau, tiết kiệm thời gian cho việc cấu hình. Chẳng hạn với một máy ảo A, trong một bài lab ta muốn nó là một máy chủ Domain Controller, nhưng trong bài lab khác ta muốn xấy dựng nó thành một máy chủ ISA. Để giải quyết vấn đề này, chúng ta có thể lưu snapshot của máy A tại thời điểm nó là domain controller, sau đó cấu hình nó thành một máy chủ ISA và lưu snapshot. Khi cần sử dụng máy ảo A với vai trò là một Domain Controller hay ISA, ta sẽ dùng trình quản lý Snapshot Manager để chuyển tới trạng thái mong muốn.

Hình 9: Cấu hình Snapshot để sử dụng máy ảo trong nhiều ngữ cảnh

Phần 2 : Hướng dẫn sử dụng VMware
1. Tạo máy ảo:
Sau khi khởi động VMWare chúng ta click vào file chọn New/ Virtual Machine tiếp theo chúng ta để mặc định và bấm Next

Hình 10: Tạo máy ảo

Lựa chọn hệ điều hành muốn cài đặt tại mục Version

Hình 11: Lựa chọn hệ điều hành

Tiếp theo chúng ta Click nút Browse để chọn nơi lưu trữ máy ảo

Hình 12: Lựa chọn nơi lưu giữ máy ảo

Ở màn hình kế tiếp chúng ta có 1 vài sự lựa chọn tuy nhiên chúng ta chỉ nên quan tâm đến 2 loại
Use Bridged networking (Lựa chọn này cho phép kết nối máy ảo vớiài máy thật)
Use host-only networking (Lựa chọn này cho phép kết nối giữa các máy ảo)

Hình 13: Lựa chọn cấu hình mạng cho máy ảo

Tiếp theo tiến hành lựa chọn dung lượng ổ đĩa cho máy ảo (Disk size GB) thông thường chỉ cần 4.0 GB là đủ cho việc cài đặt hệ điều hành Windows Server 2003

Hình 14: Lựa chọn dung lượng đĩa cứng cho máy ảo

Cuối cùng chúng ta cấu hình thay đổi 1 số thành phần bằng cách nhấn phải chuột vào Tab hiển thị máy trên đỉnh và chọn Setting

Hình 15: Lựa chọn cấu hình ổ CD-ROM

Memory Với Win2k3 chỉ nên chọn 140 MB
CD-ROM Nên sủ dụng file *.ISO (Tạo từ đĩa CD thật) nếu không thì chọn Use physical drive (Lựa chọn CD thật)
Floppy Chúng ta nên loại bỏ bằng cách bấm vào Floppy sau đó Click và Remove (Nếu không khi khởi động máy sẽ phải truy cập vào Bios máy ảo bằng nút F2 để bỏ chế độ khởi động bằng Floppy)

Nhấp nút để cài đặt máy tính công việc cài đặt diễn ra như bình thường.. các bạn lưu ý khi cài đặt máy tính nếu chúng ta bị mất chuột không thấy trên màn hình và không điều khiển nổi nguyên nhân là do chưa cài đặt VMWare tool (Để cài đặt được phải cài xong Windows) tạm thời chúng ta sử dụng tổ hợp phím Ctrl+Alt để lấy lại chuột. Mặc định chuột cũng chỉ di chuyển trong màn hình máy ảo chúng ta cũng dùng tổ hợp phím trên để thoát ra màn hình thật.
Sau khi cài đặt xong thay vì sử dụng Ctrl+Alt+Del để logon chúng ta dùng tổ hợp phím Ctrl+Alt+Ins.
Bước cuối cùng tiến hành cài đặt VMWare tool để cho máy ảo chạy nhanh hơn.

Hình 16: Cài đặt VMware tools hỗ trợ các tính năng của máy ảo

2. Sử dụng tính năng của VMWare để hỗ trợ học tập
Take Snapshot: Lưu lại cấu hình máy ảo tại thời điểm hiện tại (Tương tự như sử dụng Ghost)..để Snapshot chúng ta vào VM chọn Snapshot để hiển thị như hình dưới

Hình 17: Tạo snapshot

Capture Movie: Sử dụng tính năng ghi lại đoạn thao tác trên máy ảo bằng phim tiện cho việc xem lại bài học

Hình 18: Ghi lại thao tác trên máy ảo với tiện ích Capture Movie

Phiên bản đã có VMWare Workstation 6.5 Beta
Download v.6 2 link dưới
Download Here : VMWare Workstation hoặc VMWare Workstation

Pointers, References, Arrays, Strings

Q: How do I dynamically create an array?
A: You should use pointers. This way:

int *arr; //it can be any other type (char, float...)
arr = new int[n]; //n should be integer variable

Q: How do I dynamically create 2D array?
A: This way:

int **arr;
int N,M;
cin >> N >> M;

arr = new int*[N];
for (int i=0;i< N; i++) arr[i] = new int[M];

This code will create a 2D array, with NxM dimentions.

Q: How do I resize an array?
A: If you have created a regular array, this way:

int arr[10];

… then, you can’t resize it. Alhough, if you have created an array dynamically, using malloc() then you can use realloc() to resize it.

void *realloc( void *memblock, size_t size );

As “memblock” you should pass the array’s name, and as “size”- the new size. Include stdlib.h .

Q: How to get the length of a AnsiString?
A: The way is to use length():

int len;
len = Edit1->Text.length();

Q: Which way is correct- “int* p;” or “int *p;”?
A: Both ways are correct. It’s a matter of style (C or C++) which one you use.

A “typical C programmer writes “int *p; and explains it “*p is what is the int” emphasizing syntax, and may point to the C (and C++) declaration grammar to argue for the correctness of the style. Indeed, the * binds to the name p in the grammar.

A “typical C++ programmer writes “int* p; and explains it “p is a pointer to an int” emphasizing type. Indeed the type of p is int*.

Q: How can I declare a generic pointer pointing to a function?

typedef int (*funcptr)();

The above declaration defines a typedef, funcptr, for a pointer to a function (taking unspecified arguments and returning an int). You can now declare variables as

funcptr pf1,pf2;

The above is equivalent to the comples declaration

int (*pf1)(), (*pf2)();

Added by: Saradhi

Q: Is int *p = 4 valid? What does it mean? ie p = 4 or *p = 4?
A: Yes, int *p is perfectly valid. The above declaration declares a variable p of pointer to an integer type and points to the integer present at the memory location 4. The problem arises when you try to write to that location as

*p = 10;

The program’s behavior will be unexpected as p may point to sensitive memory locations like that of the operating system or the program itself. The program may hang or crash.

Added by: Saradhi

Q: How can I access two bytes i.e a short value using a char * pointer?
A: By judicial use of the typecast one can access any data type with a char * pointer. (In general with any pointer variable of any type).

char *t;

t = (char *) malloc(2*sizeof(char));
//Now do some allocations in the memory but do not modify t
printf("%d", *(short *) t);

By this way we can access the two byte short value in a single go.

Q: Are there void pointers?
A: All pointers are pointers to memory. Thats why they are called pointers.
A void pointer is just a pointer with no type information.It can point to anything. You may not dereference it nor may you use pointer arithmetic on it because the compiler doesn’t understand sizeof(void) and who can blame it. You use them really when you need to pass a variety of differently typed pointers to a function.memcpy() takes a void* in its parameter list. This allows you to copy single characters as easily as copying large objects. A from address,a to address and a count of bytes.

Added by: Saradhi



Cuốn Toán học rời rạc ứng dụng trong tin học


Cuốn sách là bản dịch mới nhất của cuốn Toán học rời rạc ứng dụng trong tin học theo bản gốc Discrete Mathematics and Its Applications, tái bản lần thứ 5 của tác giả Kenneth H. Rosen, NXB McGraw Hill với rất nhiều bổ sung và sửa chữa. Với lượng kiến thức phong phú, cách trình bày sư phạm và trong sáng, không sa đà vào những chứng minh phức tạp, rất nhiều ví dụ và bài tập kèm theo hướng dẫn giải (đặc biệt trong lần xuất bản này số lượng bài tập của nhiều chương tăng gần gấp đôi), cuốn sách là một tài liệu tham khảo và tra cứu rất bổ ích cho nhiều đối tượng độc giả: giáo viên và học sinh các lớp chuyên Toán – Tin, giảng viên và sinh viên các khoa Toán, Toán Tin, CNTT của các trường cao đẳng, đại học đến các sinh viên cao học và nghiên cứu sinh ngành CNTT. Cuốn Toán học rời rạc ứng dụng trong tin học cũng được coi là một trong những tài liệu tham khảo chính dùng để ôn tập trong các kì thi tuyển sinh cao học và nghiên cứu sinh ngành CNTT. Bản dịch lần này được xuất bản theo hợp đồng chuyển nhượng tác quyền giữa NXB Giáo Dục và NXB McGraw Hill.
Cuốn sách là bản dịch mới nhất của cuốn Toán học rời rạc ứng dụng trong tin học theo bản gốc Discrete Mathematics and Its Applications, tái bản lần thứ 5 của tác giả Kenneth H. Rosen, NXB McGraw Hill với rất nhiều bổ sung và sửa chữa. Với lượng kiến thức phong phú, cách trình bày sư phạm và trong sáng, không sa đà vào những chứng minh phức tạp, rất nhiều ví dụ và bài tập kèm theo hướng dẫn giải (đặc biệt trong lần xuất bản này số lượng bài tập của nhiều chương tăng gần gấp đôi), cuốn sách là một tài liệu tham khảo và tra cứu rất bổ ích cho nhiều đối tượng độc giả: giáo viên và học sinh các lớp chuyên Toán – Tin, giảng viên và sinh viên các khoa Toán, Toán Tin, CNTT của các trường cao đẳng, đại học đến các sinh viên cao học và nghiên cứu sinh ngành CNTT. Cuốn Toán học rời rạc ứng dụng trong tin học cũng được coi là một trong những tài liệu tham khảo chính dùng để ôn tập trong các kì thi tuyển sinh cao học và nghiên cứu sinh ngành CNTT. Bản dịch lần này được xuất bản theo hợp đồng chuyển nhượng tác quyền giữa NXB Giáo Dục và NXB McGraw Hill.

Vài lời về tác giả: GS Kenneth H. Rosen tốt nghiệp ĐH Michigan (1972), bảo vệ luận án Ph.D về Toán học tại Viện Công nghệ Massachusetts (MIT), một trường ĐH danh giá của Mỹ, (1976). Trước khi vào làm việc tại Phòng thí nghiệm Bell (nay là PTN AT&T) nổi tiếng ông đã từng giảng dạy các giáo trình về toán học rời rạc, lí thuyết mã và an toàn dữ liệu tại các trường ĐH Colorado, Maines, Monthmouth… Ông là tác giả của hai cuốn sách nổi tiếng: Lý thuyết số sơ cấp và các ứng dụng và Toán học rời rạc ứng dụng trong tin học đã được sử dụng rộng rãi tại hàng trăm trường ĐH trên thế giới.

“Toán học rời rạc không phải là một chủ đề mới, nhưng giáo trình hay về toán học rời rạc và ứng dụng của nó thì không có nhiều. Mà lại hay đến mức được tái bản nhiều lần và được sử dụng trong hơn 300 trường đại học như quyển sách của GS Kenneth H. Rosen thì lại càng hiếm, nếu không muốn nói là chưa hề thấy. Chất lượng của một giáo trình thể hiện ở sự súc tích của nội dung, tính sư phạm của cấu trúc và cách trình bày nội dung đó. Điều này đòi hỏi tác giả phải thấu hiểu sâu sắc chủ đề, có bề dày thực nghiệm sư phạm và dĩ nhiên có sở trường viết lách. Đọc cuốn sách này, chúng ta sẽ bị hấp dẫn bởi nhiều điều độc đáo của nó. Nhưng có lẽ điều làm kinh ngạc và thán phục nhất là khối lượng đồ sộ các ví dụ, câu hỏi, bài tập đề tài ứng dụng tin học…  giúp cho người đọc dễ dàng hiểu và biết ứng dụng có hiệu quả các kiến thức đa dạng không chỉ thuần tuý về toán học rời rạc”

Sách do Ban Tin học (Nhà xuất bản Giáo dục) triển khai. Hiện đang là giáo trình chính thức của Đại Học FPT

Ánh Tuyết

Tip: Nạp chồng toán tử ++ hay — tiền tố hoặc hậu tố ntn?

class Point
Point& operator++();       // khai báo nạp chồng toán tử ++ tiền tố
Point operator++(int);     // khai báo nạp chồng toán tử ++ hậu tố

Point& operator--();       // tiền tố
Point operator--(int);     // hậu tố

// default constructor
Point() { _x = _y = 0; }

// accessor functions
int x() { return _x; }
int y() { return _y; }
int _x, _y;

// Phần hiện thực
Point& Point::operator++()
return *this;

Point Point::operator++(int)
Point temp = *this;
return temp;

Point& Point::operator--()
return *this;

Point Point::operator--(int)
Point temp = *this;
return temp;

int main()

Ngoài ra chúng ta có thể dùng hàm friend để hiện thực các toán tử ++/– như sau:

friend Point& operator++( Point& )      // tiền tố
friend Point& operator++( Point&, int ) // hậu tố
friend Point& operator--( Point& )      // tiền tố
friend Point& operator--( Point&, int ) // hậu tố

Các điểm cần lưu ý:
– Toán tử ++/– dạng tiền tố trả về một tham chiếu đến đối tượng thuộc lớp Point
– Toán tử ++/– dạng hậu tố trả về một đối tượng thuộc lớp Point
– Đối số “int” trong dạng hậu số là bắt buộc, dùng để phân biệt với dạng tiền tố, thường thì nó mang trị mặc định là 0. Trong hầu hết các trường hợp chúng ta không quan tâm đến nó. Tuy nhiên nó vẫn có thể được sử dụng như dưới đây:

class Int
Int &operator++( int n );
int _i;

Int& Int::operator++( int n )
if( n != 0 )    // Trường hợp có sử dụng đối số trong toán tử ++/-- hậu tố
_i += n;
_i++;       // Trường hợp thông thường
return *this;

int main()



Điều đầu tiên khi lập trình viên nghĩ đến từ khóa const là những gì không thể thay đổi được (hằng số). Bạn không thể thay đổi giá trị của một hằng số. Bạn có thể dùng từ khóa const để chỉ ra rằng một giá trị nào đó sẽ không thể thay đổi được trong suốt chương trình của bạn. Một câu hỏi dành cho bạn:

Bạn có thể đặt từ khóa “const” ở những nơi nào trong chương trình của mình?

Để trả lời câu hỏi trên khi làm việc với ngôn ngữ lập trình (ở đây là C++), bạn cần phải trả lời được câu hỏi: “Tôi cần giá trị nào trở thành không thay đổi được?”.

Ở đây, trong bài viết này, xin liệt kê ra một số nơi bạn có thể đặt từ const.

1. Khi khai báo một biến, nếu bạn đặt thêm từ const thì giá trị của biến đó sẽ không thể thay đổi được trong suốt phạm vi tồn tại của biến đó.
Ví dụ các khai báo sau:

const int x = 8;
int const y = 10;

Hai dạng khai báo trên là tương đương. Giá trị của hai biến x và y sẽ không thể tha đổi được.

2. Đối với biến con trỏ, bạn cần lưu ý đến hai điều: vùng nhớ con trỏ trỏ đến và giá trị của vùng nhớ đó.

Với các khai báo:

int x = 10, y = 20;
const int *px = &x;

Khi này, giá trị của vùng nhớ mà px đang trỏ đến là không thể thay đổi được thông qua thay đổi (*px). Do đó, ta có các câu lệnh sau:

*px = 15; // incorrect
px = &y; // correct
x = 15; // correct (Để ý rằng giá trị của x vẫn có thể được thay đổi, ta chỉ không thể thay đổi giá trị này thông qua px)

Nhưng với các khai báo sau:

int x = 10, y = 20;
int* const px = &x;

Khi này, giá trị của vùng nhớ mà px trỏ đến có thể được thay đổi thông qua việc thay đổi (*px) nhưng điều đặc biệt là ta không thể làm cho px trỏ đến một vùng nhớ khác. Ta có các câu lệnh sau:

*px = 15; // correct
px = &y; // incorrect

Với khai báo sau:

int x = 10;
const int* const px = &x;

Bạn không thể thay đổi nơi px đang trỏ đến và thông qua (*px) cũng không thể thay đổi giá trị vùng nhớ đó.


Tiếp theo bài viết kỳ trước, bài này xin trình bày tác dụng của const khi hoạt động với hàm trong C++.

Giả sử ta có cấu trúc sau:

class A
int m_a;


Và ta có một hàm nhận tham số đầu vào là một đối tượng kiểu A và trả về một đối tượng kiểu A.

A functionName(A object); // object là một đối tượng kiểu A

Khi gọi hàm này với x là một đối tượng kiểu A:


Một đối tượng object sẽ được tạo và máy sẽ copy toàn bộ giá trị của x vào object rồi xử lý, sau đó sẽ trả về một đối tượng kiểu A. Vấn đề phát sinh là khi ta có một class với kích thước lớn thì việc chép giá trị vào tham số hình thức ở hàm sẽ làm cho chương trình trở nên chậm đi và đặc biệt là sẽ hao phí bộ nhớ. Do đó, ta có giải pháp là hai khai báo cho hàm đó như sau:

A functionName(A& object);
A functionName(A* object);

Hàm trên sử dụng tham số hình thức là một biến tham chiếu (reference variable) và hàm dưới dùng một biến con trỏ (pointer variable). Hai cách khai báo này sẽ cho kết quả tương tự nhau. (Sự khác nhau giữa biến tham chiếu và biến con trỏ sẽ được trình bày trong một bài gần đây). Khi này, với lời gọi hàm như trên thì địa chỉ của x sẽ được truyền vào, do đó sẽ tránh được việc phải chép cả cấu trúc với kích thước lớn.

Nhưng với khai báo như thế thì giá trị của biến truyền vào có thể bị thay đổi thông qua biến object (vì là biến con trỏ hoặc tham chiếu), trong khi với cách khai báo như cũ thì ta không hề muốn giá trị này bị sửa đổi chút nào. Do đó, từ khóa const được sử dụng:

A functionName(const A& object);
A functionName(const A* object);

Như bài trước, nếu ta muốn con trỏ object luôn trỏ đến một vị trí cố định:

A functionName(const A* const object);

Nếu hàm trả về một con trỏ trỏ đến một đối tượng kiểu A:

A* functionName( const A* const object);

Theo nhu cầu, có thể bạn mong muốn hàm sẽ trả về con trỏ mà giá trị trỏ đến là không thay đổi được thông qua con trỏ, bạn sẽ khai báo hàm như sau:

const A* functionName(const A* const object);

Nếu bạn muốn con trỏ trả về cũng không thể thay đổi được vị trí trỏ đến của nó:

const A* const functionName(const A* const object);

Tiếp theo, nếu class A của chúng ta có thêm một phương thức là long A::m_square() ; chẳng hạn. Phương thức này sẽ tính bình phương của biến A::m_a và trả về giá trị đó. Thực sự, đây chỉ là một hàm tính toán một giá trị từ giá trị của những thuộc tính trong class. Yêu cầu đặt ra là hàm này không được làm thay đổi giá trị của các thuộc tính của class. Do đó ta sẽ sử dụng một phương thức hằng bằng cách đặt từ const vào cuối hàm:

long A::m_square() const;

Bây giờ, nếu bạn lại muốn phương thức hằng của mình vẫn có thể thay đổi được giá trị của một số thuộc tính của class thì sao? Điều này vẫn có thể đạt được bằng cách sử dụng từ khóa mutable vào trước khai báo của thuộc tính nào bạn cần thay đổi giá trị bởi phương thức hằng. Chú ý là mutable không được dùng cho các biến staticcons.

Trở lại với hàm functionName(…) của ta. Khi hàm này là một phương thức của class A và bạn muốn nó trở thành một phương thức hằng thì ta có một khai báo khủng hoảng về từ khóa const:

const A* const functionName(const A* const object) const; // 5 từ const

Việc sử dụng những từ khoá const và vị trí của chúng trong chương trình là tùy theo mục đích và yêu cầu của ngữ cảnh hiện tại. Do đó, bạn hãy lưu ý khi làm việc với chúng.