We often overwrite a file accidentally by redirecting output using the ‘>’ operator to a file that already exists. For example, if we type the following command:

$ ls -l *.c > output.txt

….. assuming that output.txt exists, it will be overwritten. Just imagine that as a root user, you typed somecommand > /etc/passwd instead of somecommand < /etc/passwd or if we used ‘>’ instead of ‘>>’(append).

So how do we tell the shell not to delete the file contents by mistake ?

To do this, you need to set the noclobber variable. It can keep you from accidentally destroying your existing files by redirecting input over an already-existing file.

Type the following command:

$ set -o noclobber

Now try to write to a file called output.txt:

$ cat > output.txt

OR

ls -l > output.txt

You will get the following error message:

bash: output.txt : cannot overwrite existing file

To keep this setting across sessions, add set -o noclobber to your ~.bashrc file as follows:

$ echo ’set -o noclobber’ >> ~.bashrc

Sometimes, you may need to turn off noclobber for a single operation. Use the ‘>|’ operator to force the file to be overwritten:

$ ls /etc >| output.txt

Now, if you want to set things back to default behaviour, issue the following command:

$ set +o noclobber

Using ‘+’ rather than’-’ causes these flags to be turned off.

Note:- Original Author – Andrew D.

Many Linux users see compiling their own kernel as hard as climbing Mt. Everest. Sure, they’ve climbed a few hills in their day, compiled a small program or two, but the kernel? Much too advanced for them.

Despite what they say, compiling your own kernel is no harder than adding third-party modifications to your automobile. You need to know what hardware you currently have, the modification you want to add, how to add it.
The Stock Kernel
The kernel is the core of your Linux system. The kernel manages all the interactions between your hardware and your software; without a kernel, you couldn’t use your computer at all because none of your hardware would work.

Your Linux system already has a kernel. The default kernel is maintained and updated by the developers who created your Linux distribution. The default kernel is what is referred to as a “stock” kernel.

The stock kernel is designed to work on as many different computers as possible, and as such, has every option under the sun turned on. After all, even if you don’t use it, someone else might. This has the unfortunate side effect of making the stock kernel bulky and slow. Despite this, however, there are some reasons why you might want to use your stock kernel instead of compiling a new one.
Why Use the Stock Kernel?

1. Stock kernels are supported by your distribution’s tech support (if any). Some tech support centers will not help you if you have compiled a custom kernel.
2. Stock kernels are guaranteed to work with the external modules available from your distribution. Common external modules include nVidia/ATI graphics drivers, wireless network card drivers, and webcam drivers.
3. Stock kernels are updated by the distribution’s developers, who add bugfixes and security patches to the kernel for you. If you compile your own kernel, you have to watch for and add the bugfixes and security patches yourself.

Why Compile Your Own Kernel?

1. Custom kernels have better support for brand new hardware. Stock kernels are often a few months out of date.
2. Custom kernels are optimized specifically for your computer’s hardware, making them faster.
3. Custom kernels often have the newest experimental technology, such as instant hibernation and hardware-based virtualization.
4. Compiling your own kernel gives you something to talk about at dinner parties.

Prepare to Compile Your Own Kernel
If you’ve decided that the benefits outweigh the risks, you’re ready to begin compiling your own kernel. Going back to the car analogy, you need to first figure out what hardware you currently have.

STEP 1: Use the “Hardware Cheat Sheet” at the end of this tutorial to get a complete list of your computer’s hardware. You can find this information in your hardware manuals or from the manufacturer’s website.

STEP 2: Use your distribution’s software management system to install the following packages, if they are not already installed.

* autoconf
* automake
* binutils
* gcc
* gcc-c++
* glibc-devel
* make
* patch
* qt3-devel

Every kernel begins its life as a “vanilla” kernel, the official standardized kernel available from http://www.kernel.org.

Kernels change “flavors” depending on what patches are added to them. Some patches add new and exciting functionality while some fix bugs, but it is up to you which patches you add.

Here are some common patchsets to try:

* MM-Sources: The -mm patches are a set of patches, released by Andrew Morton, against the official kernel series. They are frequently more experimental in nature than the official series. Available at: http://www.kernel.org/pub/linux/kernel/people/akpm/
* BCM94311 Mini-PCI Wlan Patch: This patch is for the b43 native drivers included in the 2.6.24 kernel. This patch supports any BCM94311 wireless network cards which are common on new laptops (particularly Dell, HP, and Compaq). This patch is unnecessary if you use kernel 2.6.24.4 or newer. Available at: http://linuxwireless.org/download/b43/patc…6.24_for_4311_2
* Dark-Sources: Dark/sk sources are kernel patchset projects created by predatorfreak (Brett G.), focused on maintaining stablity and scalabliy. Everything that goes into these patchsets is selected based on these goals. Available at: http://sourceforge.net/projects/darkpatches

Download a Vanilla Kernel
STEP 3. Visit http://www.kernel.org with your web browser.

STEP 4. Left-click once on the “F” on the “Latest Stable Kernel” line. This will download the full Linux source package.
Unpack and Patch the Kernel
STEP 5. Start a terminal, such as Konsole or Gnome-Terminal.

STEP 6. Switch to the root user by using the su command. Type su and press the enter key, then enter the root (administrator) password and press the enter key again.

STEP 7. Switch to the /usr/src/ directory by using the cd command. Type cd /usr/src/ and press the enter key.

STEP 8. Copy the kernel sources you downloaded into the /usr/src/ directory by using the cp command. For example, I would type cp /home/andrew/linux-2.6.24.3.tar.bz2 /usr/src/ to copy the file to the /usr/src directory.

STEP 9. Unzip the kernel sources by using the tar command. Most users can simply run tar -xvf linux-2.6.24.3.tar.bz2 (changing the kernel version as necessary) and the file will automatically unzip.

STEP 10. Switch to the newly created Linux source directory by using the cd command. For example, I would type cd /usr/src/linux-2.6.24.3 to enter the Linux source directory.

STEP 11. Patch your kernel using the patch command. For example, I would type patch -p1 < /home/andrew/Desktop/patch_2.6.24_for_4311_2 because the patch file is located on my Desktop.

If you get a message similar to “hunks failed”, your patch is not compatible with the kernel source you downloaded. You will need to find or ask the patch developer for a newer patch.
Configure your Kernel
STEP 12. Type make xconfig to open the Linux Kernel Configuration screen.

When you run make xconfig, it will automatically configure itself to your current kernel options. That is, the configuration you see in the configuration screen is the “stock” kernel configuration. Most of the customization process, then, will be removing options from the kernel.

Down the left-hand side are the main categories of the Linux kernel. The top panel on the right shows the individual sub-options for each main category. The bottom panel on the right explains what the sub-option does.

Most sub-options have a checkbox next to them. If the checkbox is blank, the option is not enabled for this kernel. If the checkbox is checked, the option is compiled into the kernel. If the checkbox has a circle in it, the option is compiled as a module. You can switch each option from “not enabled” to “compiled in” to “compiled as a module” by left-clicking once on each checkbox.

The difference between “compiled into the kernel” and “compiled as a module” is fairly straight forward. Options compiled into the kernel are loaded when your system boots and cannot be removed. This is a good choice for hard drive controllers, video cards, and input devices, which are critical for a working system. Options compiled as a module are loaded after the system is up and running and can be removed if necessary. This is a good choice for USB devices, Firewire devices, or anything else that isn’t a system-critical device.

STEP 13. Configure your kernel, working methodically through the configuration screen from top to bottom. Pick a category on the left and read each sub-option’s description carefully, comparing it to your Hardware Cheat Sheet. If you need the driver, enable it, otherwise turn it off. You will not get everything right the first time, so don’t spend hours trying to get it perfect. You can always come back, reconfigure and recompile later.

STEP 14. Once you are finished configuring your kernel, left-click once on the Save button.

STEP 15. When the Save button grays out, close the configuration screen. You will be returned to the command line.

STEP 16. Run make rpm to build your kernel and package it into an installable RPM package. Depending on the speed of your processor and the number of options you enabled, this may take anywhere from 20 minutes to 4 hours.
Installing the New Kernel
STEP 17. When the kernel has finished compiling, it will tell you where it placed the newly created RPM package. Switch into the /usr/src/packages/RPMS/ directory using the cd command. Type cd /usr/src/packages/RPMS/ and press the enter key.

STEP 18. Switch into the architecture folder corresponding with your system’s architecture. If you have a 32-bit system, type cd i386 and press the enter key. If you have a 64-bit system, type cd x86_64 and press the enter key.

STEP 19. Determine what the kernel RPM package is called by typing ls *.rpm (LS *.RPM in lowercase) and pressing the enter key. All of the RPMs in the folder will be listed.

STEP 20. Install the kernel RPM using the rpm -ivh command. For example, I would type rpm -ivh kernel-2.6.24.2-1.i386.rpm. You will see the system install the RPM.
Post-installation Cleanup
STEP 21. Copy the configuration file you made in step 12 to a safe location. It is always stored as “.config”, a hidden file in the kernel source directory. For example, I would run cp /usr/src/linux-2.6.24.2/.config /home/andrew/config-2.6.24.2.

By changing the name of the file in the second-half of the command, I re-name the file to config-2.6.24.2. Because it does not have a period in front of its name, it is no longer a hidden file and will be easy to find later.

STEP 22. Run the mkinitrd program. Mkinitrd scans your kernel’s configuration and creates an “initrd” file, ensuring your system will be able to boot when you start with the new kernel.

STEP 23. Clean out the /usr/src/packages/BUILD folder by running rm -rf /usr/src/packages/BUILD/* Make sure you type this very carefully or you will accidentally erase your entire hard drive.
Make the New Kernel Bootable
You can use YaST’s “Bootloader” module to enable your kernel; this guide will walk you through editing the menu.lst file by hand.

STEP 24. Edit your /boot/grub/menu.lst using an editor like kate or gedit. From the terminal, as root, run kate /boot/grub/menu.lst.

STEP 25. Find the subsection for your current kernel. Highlight it (it should be 3 lines including title, kernel, and initrd lines) and copy it.

STEP 26. Paste it a few lines down and change any references to the kernel or the initrd to the new kernel and initrd from steps 20 and 22. For example, I would write:

title openSUSE 10.3
root (hd0,0)
kernel /boot/vmlinuz-2.6.24 root=/dev/sda1 vga=0×317 resume=/dev/sda5 splash=silent showopts
initrd /boot/initrd-2.6.24

STEP 26. Save the file and close the terminal.
Analyze Your Success
STEP 27. Reboot your system. When you are given the choice of operating systems to boot, you should see your new kernel listed next to the stock kernel.

STEP 28. Select and boot from your new kernel.

If your new kernel does not boot, manually reset your computer and boot into the stock kernel. Then,

1. Re-enter the /usr/src/kernel-name folder.
2. Run make clean to clean up the folder from your last kernel compile.
3. Repeat steps 12 through 28 above.

STEP 29. Test each and every one of your devices.

If your devices are all working properly, congratulations! You have successfully compiled a working kernel.

If they are not working appropriately (or do not work at all), your kernel configuration probably missed something that device needed. To fix this,

1. Re-enter the /usr/src/kernel-name folder.
2. Run make clean to clean up the folder from your last kernel compile.
3. Repeat steps 12 through 28 above.