Tips and Tricks for Linux

Manually change the default login session

tshrinivasan — Wed, 02 Jan 2008 08:43:56 +0000

1) Goto the user’s home directory

  $ cd

2) edit the file .dmrc

  $ gedit .dmrc

3) change the session to kde (or) gnome
[Desktop]
Session=kde
4) save the file and logout

One click monitor power-down for Linux

tshrinivasan — Thu, 20 Dec 2007 05:57:33 +0000

If you’re running a Linux-powered laptop and you want to switch off
the screen, without waiting for the laptop to go into sleep mode, then
this is a great tip from Tombuntu.

To switch the your monitor off use the command: sleep 1 && xset dpms force off.

The sleep 1 (wait for one second) is
needed only when you are typing the command in a terminal. This is
because the command is executed as soon as the enter key is pressed,
when it lifts up X turns the monitor back on.

To turn this into a Linux desktop shortcut, right-click on your desktop and select “create new launcher”.

The “command” setting must be set to “xset dpms force off” (without the sleep 1).

source:

http://www.tectonic.co.za/view.php?src=rss&id=1943

All about Linux swap space

tshrinivasan — Tue, 04 Dec 2007 03:50:37 +0000

December 03, 2007 (4:00:00 PM) - 11 hours, 49 minutes ago

By: Gary Sims

When
your computer needs to run programs that are bigger than your available
physical memory, most modern operating systems use a technique called
swapping, in which chunks of memory are temporarily stored on the hard
disk while other data is moved into physical memory space. Here are
some techniques that may help you better manage swapping on Linux
systems and get the best performance from the Linux swapping subsystem.

Linux
divides its physical RAM (random access memory) into chucks of memory
called pages. Swapping is the process whereby a page of memory is
copied to the preconfigured space on the hard disk, called swap space,
to free up that page of memory. The combined sizes of the physical
memory and the swap space is the amount of virtual memory available.

Swapping is necessary for two important reasons. First, when the
system requires more memory than is physically available, the kernel
swaps out less used pages and gives memory to the current application
(process) that needs the memory immediately. Second, a significant
number of the pages used by an application during its startup phase may
only be used for initialization and then never used again. The system
can swap out those pages and free the memory for other applications or
even for the disk cache.

However, swapping does have a downside. Compared to memory, disks
are very slow. Memory speeds can be measured in nanoseconds, while
disks are measured in milliseconds, so accessing the disk can be tens
of thousands times slower than accessing physical memory. The more
swapping that occurs, the slower your system will be. Sometimes
excessive swapping or thrashing occurs where a page is swapped out and
then very soon swapped in and then swapped out again and so on. In such
situations the system is struggling to find free memory and keep
applications running at the same time. In this case only adding more
RAM will help.

Linux has two forms of swap space: the swap partition and the swap
file. The swap partition is an independent section of the hard disk
used solely for swapping; no other files can reside there. The swap
file is a special file in the filesystem that resides amongst your
system and data files.

To see what swap space you have, use the command swapon -s. The output will look something like this:

Filename        Type            Size    Used    Priority

/dev/sda5       partition       859436  0       -1

Each line lists a separate swap space being used by the system.
Here, the ‘Type’ field indicates that this swap space is a partition
rather than a file, and from ‘Filename’ we see that it is on the disk
sda5. The ‘Size’ is listed in kilobytes, and the ‘Used’ field tells us
how many kilobytes of swap space has been used (in this case none).
‘Priority’ tells Linux which swap space to use first. One great thing
about the Linux swapping subsystem is that if you mount two (or more)
swap spaces (preferably on two different devices) with the same
priority, Linux will interleave its swapping activity between them,
which can greatly increase swapping performance.

To add an extra swap partition to your system, you first need to
prepare it. Step one is to ensure that the partition is marked as a
swap partition and step two is to make the swap filesystem. To check
that the partition is marked for swap, run as root:

fdisk -l /dev/hdb

Replace /dev/hdb with the device of the hard disk on your system
with the swap partition on it. You should see output that looks like
this:

 Device Boot    Start   End     Blocks  Id      System

/dev/hdb1       2328    2434    859446  82      Linux swap / Solaris

If the partition isn’t marked as swap you will need to alter it by
running fdisk and using the ‘t’ menu option. Be careful when working
with partitions — you don’t want to delete important partitions by
mistake or change the id of your system partition to swap by mistake.
All data on a swap partition will be lost, so double-check every change
you make. Also note that Solaris uses the same ID as Linux swap space
for its partitions, so be careful not to kill your Solaris partitions
by mistake.

Once a partition is marked as swap, you need to prepare it using the mkswap (make swap) command as root:

mkswap /dev/hdb1

If you see no errors, your swap space is ready to use. To activate it immediately, type:

swapon /dev/hdb1

You can verify that it is being used by running swapon -s.
To mount the swap space automatically at boot time, you must add an
entry to the /etc/fstab file, which contains a list of filesystems and
swap spaces that need to be mounted at boot up. The format of each line
is:

Since swap space is a special type of filesystem, many of these parameters aren’t applicable. For swap space, add:

/dev/hdb1       none    swap    sw      0       0

where /dev/hdb1 is the swap partition. It doesn’t have a specific mount point, hence none. It is of type swap with options of sw, and the last two parameters aren’t used so they are entered as 0.

To check that your swap space is being automatically mounted without having to reboot, you can run the swapoff -a command (which turns off all swap spaces) and then swapon -a (which mounts all swap spaces listed in the /etc/fstab file) and then check it with swapon -s.

Swap file

As well as the swap partition, Linux also supports a swap file that
you can create, prepare, and mount in a fashion similar to that of a
swap partition. The advantage of swap files is that you don’t need to
find an empty partition or repartition a disk to add additional swap
space.

To create a swap file, use the dd command to create an empty file. To create a 1GB file, type:

dd if=/dev/zero of=/swapfile bs=1024 count=1048576

/swapfile is the name of the swap file, and the count of 1048576 is the size in kilobytes (i.e. 1GB).

Prepare the swap file using mkswap just as you would a partition, but this time use the name of the swap file:

mkswap /swapfile

And similarly, mount it using the swapon command: swapon /swapfile.

The /etc/fstab entry for a swap file would look like this:

/swapfile       none    swap    sw      0       0

How big should my swap space be?

It is possible to run a Linux system without a swap space, and the
system will run well if you have a large amount of memory — but if you
run out of physical memory then the system will crash, as it has
nothing else it can do, so it is advisable to have a swap space,
especially since disk space is relatively cheap.

The key question is how much? Older versions of Unix-type operating
systems (such as Sun OS and Ultrix) demanded a swap space of two to
three times that of physical memory. Modern implementations (such as
Linux) don’t require that much, but they can use it if you configure
it. A rule of thumb is as follows: 1) for a desktop system, use a swap
space of double system memory, as it will allow you to run a large
number of applications (many of which may will be idle and easily
swapped), making more RAM available for the active applications; 2) for
a server, have a smaller amount of swap available (say half of physical
memory) so that you have some flexibility for swapping when needed, but
monitor the amount of swap space used and upgrade your RAM if
necessary; 3) for older desktop machines (with say only 128MB), use as
much swap space as you can spare, even up to 1GB.

The Linux 2.6 kernel added a new kernel parameter called swappiness
to let administrators tweak the way Linux swaps. It is a number from 0
to 100. In essence, higher values lead to more pages being swapped, and
lower values lead to more applications being kept in memory, even if
they are idle. Kernel maintainer Andrew Morton has said that he runs
his desktop machines with a swappiness of 100, stating that “My point
is that decreasing the tendency of the kernel to swap stuff out is
wrong. You really don’t want hundreds of megabytes of BloatyApp’s
untouched memory floating about in the machine. Get it out on the disk,
use the memory for something useful.”

One downside to Morton’s idea is that if memory is swapped out too
quickly then application response time drops, because when the
application’s window is clicked the system has to swap the application
back into memory, which will make it feel slow.

The default value for swappiness is 60. You can alter it temporarily (until you next reboot) by typing as root:

echo 50 > /proc/sys/vm/swappiness

If you want to alter it permanently then you need to change the vm.swappiness parameter in the /etc/sysctl.conf file.

Conclusion

Managing swap space is an essential aspect of system administration.
With good planning and proper use swapping can provide many benefits.
Don’t be afraid to experiment, and always monitor your system to ensure
you are getting the results you need.

–>

Read in the original layout at: http://www.linux.com/feature/121916

APT-build — optimize your Debian!

tshrinivasan — Mon, 26 Nov 2007 07:22:29 +0000

Certainly most of the Linux users would like to have their
systems fully optimized for their rigs but do not have the stamina or
enough knowledge to play with the Gentoo installation paradigm. But
here comes the rescue — an apt-build goody available under every distro
armed with the big gun – APT package manager.

Author: Gallus Annonimus

Time to make the beast work for us. First we have to install it. Issue the command:

apt-get install apt-build

Now it’s time to configure it. In doing so, we’ll be asked for an
optimization level — whether we want to create an apt-build repo for
APT, and a question about processor architecture. Of course all options
can be reconfigured in this way:

dpkg-reconfigure apt-build

The above command offers two additional options for the gcc compiler and make builder. Their descriptions can be found in system manuals: man gcc and man make.

Optimizing system

Let’s go to the next step and start optimizing our system. Our program makes use of deb-src entries contained in the etc/apt/sources.list file. Thanks to the source addresses compilation and installation processes are fully automatic (similar to emerge found in Gentoo). Apt-build downloads sources of the main application and its dependencies, compiles them, creates a deb package, and finally installs the package.

We are offered a broad spectrum of options. I list only a few basic ones:

apt-build update — updates repo list,
apt-build upgrade — updates operating system,
apt-build install program — installs an application,
apt-build world — something for hard-core users, it recompiles whole system!

Other useful options:

--noupdate — useful for underpowered machines and when we do not want to update repos (apt-build refreshes repos with every invocation),
--yes — we do not have time to approve every stupid question during program installation,
--force-yes — we approve unauthorized packages
(ATTENTION: apt-build does not install unauthorized packages — what’s
worse is it won’t ask us for this; the option’s highly recommended),
--reinstall — reinstalls a package,
--rebuild — builds a package from the beginning.

Make your Debian anew!

Anyone ready to jump to the deep waters of system recompilation,
after reading above remarks, has to acquaint himself with a few things
without which the compilation process will not yield.

At first the apt-build command should spit out the message:

-----Rebuilding the world!-----

-----Building package list-----

Please read README.Debian first.

Of course, the system failed to rebuild due to the fact it didn’t
have a full list of system packages. We’ll try to amend this omission
with the following command (it can be issued in one row without the
backslash too):

dpkg --get-selections | awk '{if ($2 == "install") print $1}'> 

 /etc/apt/apt-build.list

I suggest to add two options — --yes and --force-yes
— to make the rebuilding process fully automatic. Recompilation should
start without a problem now. But you will never achieve 100% certainty
that the compilation will go smoothly, that it will not stop at some
point even after you’ve made every theoretical precaution.

But what about USE flags?

A lot of you wonder whether we could have accessed USE flags, as we
were able to recompile our system like Gentoo distros. For those
uninitiated into compilation secrets: USE flags are special options for
portage (Gentoo package control system). They free us from
typing a lot of compilation options. For example, if we use GNOME and
we do not need KDE parts we can preset the compiler to process
applications for the first graphical environment only. Sorry, but
apt-build cannot manage USE flags.

In spite of being at an early stage of development, the program is
promising. In my opinion it will be able to compete with Gentoo’s portage in the future. But as for today, the apt-build system it too young and underdeveloped to compete with the stable, mature, and easy to use portage.
Anyway, don’t worry. Debian wasn’t created to be compiled by users,
contrary to Gentoo. Users should make use of Debian’s gigantic default
repositories of ready-to-use binaries. But who from us, the users,
never wanted to optimize his system in the past and wouldn’t like to
optimize it in the future?

source:
http://polishlinux.org/linux/debian/apt-build-optimize-debian/

Recovering Data from Windows systems by using Linux

tshrinivasan — Wed, 21 Nov 2007 03:17:32 +0000

The hard disk failures, boot failure, bad sectors are as usual as normal booting in windows. The FAT and NTFS file systems can not withstand high stresses and strains.

When a disk failures, in windows, there is hardly no way to recover the data, unless you steal some proprietary software from friends or internet.

But, Linux comes with tons of tools and utilities. So, recovery from the partitions is so easy with those power tools.

dd and mount are the great simple tools that do the magic.

Here is the detailed document

Note:
Port25 is Microsoft’s OpenSource software lab, and they have created a document where they show how to recover data from Windows systems using Linux.

CLI Magic: Video conversion with mencoder

tshrinivasan — Wed, 21 Nov 2007 03:00:42 +0000

Mencoder
is part of the MPlayer media player package. While MPlayer can play
audio and video files, mencoder converts and manages multimedia files.
The application has a ton of graphical user interfaces, but you can use
it from the command line to produce video files in almost any format
you want. Here’s how.

Among
the file types mencoder can handle are MPEG/VOB, AVI, ASF/WMA/WMV, RM,
QT/MOV/MP4, Ogg/OGM, MKV, VIVO, FLI, and FLV. The command syntax is
straightforward despite a wealth of options. There’s little mencoder
can’t do when it comes to multimedia conversion.

Here’s a simple command that converts an MPG file to AVI format:

mencoder file.mpg -o file.avi -ovc lavc -oac lavc

-ovc and -oac represent the options for the video and audio
codecs that mencoder will use. To find out what video codecs are
installed on your system, use mencoder -ovc help and mencoder -oac
help.

Suppose you need a file with no compression on the audio part and
decide to use PCM. You can specify the type of audio codec you want by
using the acodec option:

mencoder file.mpg -o file.avi -ovc lavc -oac lavc -lavcopts acodec=pcm

When it comes to MP3 compression, you can also choose a bitrate using abitrate:

mencoder file.mpg -o file.avi -ovc lavc -oac lavc -lavcopts acodec=libmp3lame:abitrate=128

You can use lameopts if you have libmp3lame installed and want to
add extra options to the encoding process. You can also create files
with variable bit rate audio compression:

mencoder file -o file.avi -ovc lavc -oac mp3lame -lameopts vbr=2:q=3

where q can be any number between 0 and 9.

You can do the same thing with the video part of the file:

mencoder file.mpg -o file.avi -ovc lavc -oac lavc -lavcopts acodec=libmp3lame:abitrate=128 vcodec=xvid

If you don’t want to use video compression, try vcodec=copy. With
that option, the frames will be copied one by one from the source file.

You can use xvid or divx directly, without going through lavc:

mencoder -ovc xvid -oac mp3lame -o destination.avi source.avi

If you need customized quality, you can add a few options to the XviD compression:

mencoder -ovc xvid -oac mp3lame -xvidencopts bitrate=878 -o destination.avi source.avi

The higher the bitrate, the better quality the video file will be. The downside is a larger file size.

Now let’s get fancy and make an XviD copy of a DVD using two passes.
During the first pass, mencoder analyzes the content of the file; on
the second pass mencoder encodes the new file based on the information
obtained. By using two passes you can produce a better compressed file,
but you’ll have to wait a little longer for it, and you’ll probably see
CPU usage at 90% during the conversion:

mencoder dvd:// -oac mp3lame -ovc xvid -xvidencopts pass=1 -o /dev/null

mencoder dvd:// -oac mp3lame -ovc xvid -xvidencopts pass=2:bitrate=800 -o xvidfile.avi

You can use whatever bitrate option you want. If you need to squeeze
a DVD into a 700MB XviD file, you could use the following command,
which forces the file size of the resulting AVI to 700MB.:

mencoder dvd:// -ovc xvid -oac mp3lame -xvidencopts bitrate=-700000 -o file.avi

If you don’t like the CPU being used to the max and want to leave
resources for launching other applications, use the nice option, which
will run the program with the lowest priority when it comes to process
scheduling:

nice -n 19 mencoder dvd:// -ovc xvid -oac mp3lame -xvidencopts bitrate=-700000 -o file.avi

Suppose you have a folder full of small video files of different
types and would like to merge them into one big movie for easy
watching. First, rename them so that they’re in the order you want them
to appear in the final video, then use:

mencoder * -o output.avi

If you want to add a particular audio file to a movie, use:

mencoder source.avi -o destination.avi -ovc copy -oac mp3lame -audiofile file.wav (for uncompressed files)

mencoder source.avi -o destination.avi -ovc copy -oac copy -audiofile file.mp3 (for compressed files)

To convert a video file to run on a device running iPodLinux, use:

mencoder -ovc raw -ofps 15 -oac pcm -vf scale=176:-2,expand=176:132,format=bgr16 input.file -o output.avi

This produces a RAW AVI file with uncompressed audio data and scales it so it fits the Nano’s tiny screen perfectly.

I have a Pocket PC that I sometimes bring with me on business trips.
I take a couple of movies I haven’t seen in a while and convert them to
fit on a 512MB SD card:

mencoder -oac mp3lame -lameopts mode=3:preset=24 -ovc lavc -lavcopts vcodec=mpeg4:vhq:vbitrate=384:keyint=250 -vop expand="320:240" -o outputfile.avi inputfile.avi

mencoder input.avi -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=200:abitrate=48 -vop scale=320:240 -oac copy -o output.avi

The difference here is that the latter command scales the file and
the former fills the PDA’s 320×240-pixel screen with the movie.

If you have a webcam and want to record the output, use:

mencoder tv:// -tv driver=v4l:device=/dev/video0:width=640:height=480:forceaudio -ovc lavc -oac lavc -lavcopts vcodec=mpeg4:acodec=mp3 -ffourcc divx -o test.avi

The command records anything output by /dev/video0 in 640×480 resolution, using DivX with MP3 audio as an output result.

As you can see, you can use mencoder to convert almost any type of
video file in several ways. It works fast, it works well, and I
wouldn’t change it for any other application, be it GUI-friendly or
not.

However, if you feel you need a graphical interface to convert videos, I suggest one of the following: KMencoder, Konverter, Kmenc15, GMencoder, AcidRip or MenGUI.

Razvan
T. Coloja has published more than 150 Linux and IT-related articles in
print and online magazines. He is an editor for a Romanian magazine and
one of the maintainers and editors of www.mylro.org, a Romanian
Linux/OSS portal and community.

source:
http://www.linux.com/feature/121385

Solving resource contention problems with fuser

tshrinivasan — Fri, 16 Nov 2007 14:46:31 +0000

Have you ever tried to
unmount your USB thumb drive only to get the message “device is busy”?
Like me, you probably thought, “I know I closed that file manager
window. What’s keeping it busy now?” fuser
is a command that can answer that question for you, along with similar
questions about what processes are using what files or sockets.

The
fuser command command takes as an argument either a file path, the name
of a mounted filesystem, or a namespace/port combination (eg.
Telnet/TCP). If the specified resource is being used, fuser displays
the name of the resource along with the ID of each process accessing
it, followed by a letter signifying the type of access the process has.
The following is a list of possible access types:

c — the process’s current directory was specified
e — the process’s executable file was specified
f — the process has the specified file open for reading
F — the process has the specified file open for writing
r — the process is rooted at the specified directory
m — the process has the specified file memory mapped or loaded as a shared library

In the USB drive example above, if you type fuser -v -m /media/usbdrive, fuser reports back with something like:

                  USER    PID  ACCESS COMMAND

/media/usbdrive:   duane   4533 ..c.. bash

The -m tells fuser that you are specifying a mount point (or a file on that mount point) and the -v
tells fuser that you want verbose output, which gives you the column
headers and displays the owner of the process. Looking at the output
you can see that the ID of the process that’s accessing the USB
thumbdrive is 4533. If you would like to know more information about
that process, you can run the command ps aux | grep 4533. If you just want to kill the process so you can unmount the drive, you can add -k
to fuser’s command line and all processes that are accessing the
specified mount point will be killed. If you are unsure about killing
the process without reviewing it first, you can add -i with -k to prompt you before you kill each process.

fuser can also tell you which processes are accessing network ports.
For example, if you try to start an FTP server and you get a message
indicating that the port is busy, you can run the command fuser -v -n tcp 21 and fuser will display

          USER  PID  ACCESS COMMAND

21/tcp:    root  4391 F.... vsftpd

This means that the vsftpd FTP server is already running on port 21.
Here again you can automatically kill the process by adding -k and prompt before killing by adding -i. If you are not familiar with the ports on which services run, you can specify the name of the service to fuser instead (eg. fuser -n tcp ftp).

fuser is a useful command-line tool that can give you the
information you need to free up resources so you can safely unmount a
USB drive or start your FTP server. fuser can also be used in scripts
to determine whether a file is being used before deleting it, whether a
port that your application wants is already being used by another
service, or whether a mounted filesystem is being used before you
unmount it to perform a filesystem check. As with every other command,
you can learn more about fuser and its switches by looking at its man
page.

Duane
Odom is a computer programmer for the US Department of Defense and a
freelance writer. He has been a Linux user since 2001.

source:
http://www.linux.com/feature/121049

Keeping separate history files for users who su to root

tshrinivasan — Fri, 16 Nov 2007 14:43:30 +0000

THIS IS NOT INTENDED TO BE USED AS A SECURITY SOLUTION.
If
you’re like me and work for a company who has many linux admins all
logging into servers and then su’ing to root, you may find this tip
beneficial. It is simply 3 lines that you add to root’s .bash_profile
which will keep separate history files for each admin that su’s to root
and the commands they ran. It will allow you to go back and see what
the user did as root. Granted the user could delete the history file,
but we are only interested in keeping separate history files and going
back to review if necessary. You may need to implement a policy or have
an agreement with the admins which states no one will delete the
history files.

So if you’re ready to try this out, fire up vi and add the below lines to root’s .bash_profile

export HISTSIZE=3000
export HISTFILESIZE=5000
export HISTFILE=/root/.bash_hist-$(who am i | awk ‘{print $1}’;exit)

Save
the file and you’re good to go. Now when an admin logs in, su’s to root
and logs out; a hidden file will be created in the root directory
called .bash_hist-userid

Here’s an example:

If user jsmith logged in and then su’d to root, you would see a file called .bash_hist-jsmith in the root home directory after the user logs out. Hope this helps

This tip is courtesy of my senior admin Steve V.

Have fun!

source:
http://moonpup.blogspot.com/2007/11/keeping-separate-history-files-for.html

Which network interface is which?

tshrinivasan — Fri, 16 Nov 2007 14:42:40 +0000

Servers
typically have more than one network interface card. In fact, at my
company most linux servers have 5 cards. Just the other day we had to
troubleshoot network connectivity with a box that we could not get back
up on the network. To make matters worse, we had no idea which physical
interface was which. This is where ‘ethtool’ is your best friend. All
we did was run the command below and we could see which physical card
was giving us the problem.

ethtool -p eth2 5

The result
of this command will blink the light on the network card eth2 for 5
seconds. Of course you can set whatever number of seconds you like.
Next time you’re not sure which card is which, fire up good ‘ol ethtool.

source:
http://moonpup.blogspot.com/2007/11/which-network-interface-is-which.html

How to ‘grep’ in color

tshrinivasan — Fri, 16 Nov 2007 14:41:35 +0000

Have
you ever had to grep for words in a log file or document and wish they
jumped out at you? Well here’s a real easy way to accomplish this by
using alias.

Modify the .bashrc file in your home directory by adding the following line:

alias grep=’grep –color=auto’

Save
the file and log out and back in again. If you don’t want to logout
just type the above on the command line and hit enter. Now grep a log
file for a keyword and see what comes back! Here’s what I get when I
grep on .i386 in the /var/log/messages file

[root@testbox ~]# cat /var/log/messages|grep i386

Nov 13 07:07:54 testbox yum: Updated: gnome-python2-extras – 2.19.1-10.fc8.i386
Nov 13 07:08:01 testbox yum: Updated: elfutils-libelf – 0.131-1.fc8.i386
Nov 13 07:08:03 testbox yum: Updated: link-grammar – 4.2.5-1.fc8.i386
Nov 13 07:08:27 testbox yum: Updated: tomboy – 0.8.1-3.fc8.i386
Nov 13 07:08:28 testbox yum: Updated: gnome-python2-libegg – 2.19.1-10.fc8.i386

source:
http://moonpup.blogspot.com/2007/11/how-to-grep-in-color.html