by Ellen Siever 08/01/2000 -------------------------------------------------------------------------------- Everyone
develops their favorite tips and tricks for using Linux based on their
own experience and the kind of work they are doing. Here are some of
mine. These tips may seem simple, but I've found it's often the simple
tricks that are the most useful in day-to-day work. Switch
to another console. Linux lets you use "virtual consoles" to log on to
multiple sessions simultaneously, so you can do more than one operation
or log on as another user. Logging on to another virtual console is
like sitting down and logging in at a different physical terminal,
except you are actually at one terminal, switching between login
sessions. Virtual consoles are especially useful if you aren't running X, but you can use them even if you are. In
early versions of the kernel (pre-1.1.54), the number of available
virtual consoles was compiled into the kernel. With more recent
kernels, 63 virtual consoles are available, with 6 set up by default in
the file /etc/inittab. Use the key combination Alt+Fn to
switch between virtual consoles, where Fn is one of the function keys
F1-F6. (If you are in X, you'll probably need to use Ctrl-Alt-Fn
instead.) Alt+F7 gets you back to your X session, if one is running.
You can rotate between consoles with the Alt-right arrow and Alt-left
arrow key combinations. Temporarily use a different shell.
Every user account has a shell associated with it. The default Linux
shell is bash; a popular alternative is tcsh. The last field of the
password table (/etc/passwd) entry for an account contains the login
shell information. You can get the information by checking the password
table, or you can use the finger command. For example, the command
"finger ellen" shows, among other things, that I use /bin/tcsh. Related
Reading Linux in a Nutshell By Ellen燬iever, Stephen燬painhour, Jessica P.燞ekman, Stephen燜iggins Table of Contents Index Sample Chapter Read Online--Safari Search this book on Safari: Only This Book All of Safari Code Fragments only The
command chsh changes the login shell for all future logins; that is, it
changes the account entry in the password table to reflect the new
shell. However, you can also temporarily use another shell at any time
by simply running the new shell. For example, if I want to try
something out in bash, I can type "bash" at the prompt and be put into
a bash shell. Typing either Ctrl-d or exit gets rid of that shell and
returns me to my tcsh session. Print a man page. Here are a few useful tips for viewing or printing manpages: To print a manpage, run the command: man | col -b | lpr
The col -b command removes any backspace or other characters that would make the printed manpage difficult to read.
Also,
if you want to print a manpage that isn't in a standard man directory
(i.e., it's in a directory that isn't specified in the MANPATH
environment variable), you can specify the full pathname of the
manpage, including the full filename:
man /work/myapp/mymanpage.1
If
you use the Emacs editor, you can view a manpage with the command
Meta-x man; Emacs then prompts you for the name of the manpage. You can
view the page or print it as you would any other Emacs buffer.
As
a last resort, you can format the manpage directly with the groff
command. However, the default output is a PostScript file, so you'll
want to either send it to a PostScript printer or to a viewer such as
ghostview:
groff -man /work/myapp/mymanpage.1 | ghostview -i
You
can get ASCII output with the -a option, but the result is unformatted
text. Not pretty to read, but it might suffice if nothing else works.
Use
command substitution to simplify complex operations. Command
substitution lets you use the output of one command as an input
argument to another command. To use command substitution, determine
what command will generate the output you want, put that command in
backquotes, and use it as an argument to another command. For example,
I often use command substitution to recursively grep the files in a
directory tree:
grep 'Title' `find /work -type f -name 'chap*' -print` > chaptitles
The
portion of this command in backquotes is a find command that builds a
list of chapter files in the /work directory. That list is then used to
provide the set of input files for grep to search for titles. The
output is saved in a file called chaptitles.
Look inside a
non-text file. Sometimes you really want to see inside a binary file.
Maybe there isn't a manpage and you're looking for usage information,
or perhaps you're looking for information about who wrote a program or
what application a file is associated with.
The strings command is
perfect for that purpose--it searches through a file looking for
sequences of printable character strings and writes them to standard
output. You can pipe the output through a pager like more, or if you
are looking for particular text, you can pipe the output to the grep
command.
Use the locate command. Looking for an easier way
to find files than the find command? Try using locate. In contrast to
find's complexity, locate is the ultimate in simplicity. The command:
locate
searches
an internal database and prints the pathnames of all files and
directories that contain the given string in their names. You can
narrow down the search by piping the output to grep. For example, the
following finds all files containing the string "kde" that are in bin
directories:
locate kde | grep bin
The strings don't
have to be complete names; they can be partial strings, such as "gno"
instead of spelling out "gnome". The -r option lets you use a regular
expression (in quotes):
locate -r 'gno*'
One thing to be aware of is that locate is case-sensitive: Searching for HOWTO and for howto will give you different results.
Rather
than searching the disk each time, as find does, locate depends on the
creation and maintenance of a database. Because it only has to search
the database, not the disk, locate is faster than find. On the other
hand, the results are only as current as the database.
The
locate database is generally updated daily by a cron job, but you can
update it manually by running the command updatedb (usually as root).
If you are adding new applications or deleting old files and you don't
want to wait for the next day to have an up-to-date database, you might
want to run it manually.
Use dmesg to view startup
messages. The dmesg command provides an easier way to see the boot
messages than trying to read them before they scroll off the screen.
When Linux boots, the kernel startup messages are captured in a buffer
known as the kernel ring buffer; dmesg prints the contents of that
buffer. By default, dmesg prints its output to the screen; you can of
course redirect the output to a file:
% dmesg > bootmsg
Find
out what kernel version you are using. Do you ever need to know what
version of the Linux kernel is running on your system? You can find out
with the uname command, which prints information about the system.
Issued with the -r option, uname prints the kernel version:
% uname -r
2.2.14-5.0
Other
uname options provide information such as the machine type, the name of
the operating system, and the processor. The --all option prints all
the available information.
Use df and du to maintain your
disk. Use the df (display filesystem) command to keep an eye on how
much space each of your filesystems occupies and how much room is left.
It's almost inevitable that if you like to download new software and
try it out, you'll eventually fill up your disk. df has some options,
but running it without options provides the basic information--the
column labeled Use% tells you how full each filesystem is:
% df Filesystem 1k-blocks Used Available Use% Mounted on /dev/hda3 1967156 1797786 67688 96% /
Oops,
time to clean house... and that's where du (disk usage) comes in handy.
The du command provides the information you need to find the big space
users, by printing the amount of disk space used for each file,
subdirectory, and directory. You can specify the directory du is to
start in, or let it default to the current directory.
If you
don't want to run du recursively through subdirectories, use the -s
option to summarize. In that case, you need to specify all the
directories you are interested in on the command line. For example:
% du -s /usr/X11R6
142264 /usr/X11R6
% du -s /usr/X11R6/*
34490 /usr/X11R6/bin
1 /usr/X11R6/doc
3354 /usr/X11R6/include
97092 /usr/X11R6/lib
7220 /usr/X11R6/man
106 /usr/X11R6/share
With
the information provided by du, you can start in the directories that
occupy the most disk space and delete or archive files you no longer
actively use.
Permit non-root users to mount or unmount
drives. While hard drives are normally mounted automatically when the
system is booted, other drives such as the floppy drive and the CD-ROM
are generally not mounted until they are going to be used, so that
disks can be inserted and removed. By default, root privileges are
required for doing the mount (or unmount). However, you can modify the
entries in the filesystem table, /etc/fstab, to let other users run the
mount command. Do this by adding the option "user" to the appropriate
entry:
/dev/fd0 /mnt/floppy auto noauto,user 0 0 /dev/cdrom /mnt/cdrom iso9660 noauto,ro,user,unhide 0 0
You
can see what filesystems are currently mounted, and what options they
were mounted with, by looking at the file /etc/mtab or by running the
mount command with no options or arguments. |
