1696 lines
77 KiB
Plaintext
1696 lines
77 KiB
Plaintext
|
From VMS to Linux HOWTO
|
|||
|
|
|||
|
By Guido Gonzato, ??, and Mike Miller, ??
|
|||
|
|
|||
|
v1.1.4, 22 September 2004
|
|||
|
|
|||
|
|
|||
|
This HOWTO is aimed at all those who have been using VMS and now need or want
|
|||
|
to switch to Linux, the free UNIX clone. The transition is made (hopefully)
|
|||
|
painless with a step--to--step comparison between commands and available
|
|||
|
tools.
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
Table of Contents
|
|||
|
1. Introduction
|
|||
|
1.1. Why Linux?
|
|||
|
1.2. Comparing Commands and Files
|
|||
|
|
|||
|
|
|||
|
2. Short Intro
|
|||
|
2.1. Files
|
|||
|
2.2. Directories
|
|||
|
2.3. Programs
|
|||
|
2.4. Quick Tour
|
|||
|
|
|||
|
|
|||
|
3. Editing Files
|
|||
|
4. TeXing
|
|||
|
5. Programming
|
|||
|
5.1. Fortran
|
|||
|
5.2. Using make
|
|||
|
5.3. Shell Scripts
|
|||
|
5.4. C
|
|||
|
|
|||
|
|
|||
|
6. Graphics
|
|||
|
7. Mail and Internet Tools
|
|||
|
8. Advanced Topics
|
|||
|
8.1. Permissions and Ownership
|
|||
|
8.2. Multitasking: Processes and Jobs
|
|||
|
8.3. Files, Revisited
|
|||
|
8.4. Print Queues
|
|||
|
|
|||
|
|
|||
|
9. Configuring
|
|||
|
10. Useful Programs
|
|||
|
10.1. Browsing Files: less
|
|||
|
10.2. Numbered Backups Under Linux
|
|||
|
10.3. Archiving: tar & gzip
|
|||
|
|
|||
|
|
|||
|
11. Real Life Examples
|
|||
|
12. Tips You Can't Do Without
|
|||
|
13. Reading VMS tapes from Linux
|
|||
|
13.1. Introduction
|
|||
|
13.2. The Basics
|
|||
|
13.3. Some details
|
|||
|
13.4. Comment on Block Size
|
|||
|
|
|||
|
|
|||
|
14. The End
|
|||
|
14.1. Copyright
|
|||
|
14.2. Disclaimer
|
|||
|
|
|||
|
|
|||
|
|
|||
|
1. Introduction
|
|||
|
|
|||
|
1.1. Why Linux?
|
|||
|
|
|||
|
You've heard that UNIX is difficult and balk at the prospect of leaving VMS,
|
|||
|
don't you? Don't worry. Linux, one of the finest UNIX clones, is not more
|
|||
|
difficult to use than VMS; actually, I find it easier. Although VMS
|
|||
|
aficionados may not agree, in many people's opinion Linux is much more
|
|||
|
powerful and versatile.
|
|||
|
|
|||
|
Linux and VMS are both good operating systems and accomplish essentially the
|
|||
|
same tasks, but Linux has a few features that make it a good alternative to
|
|||
|
VMS. Moreover, Linux is available for PCs while VMS is not, and modern
|
|||
|
Pentium-based Linux machines can outperform a VAX. The icing on the cake is
|
|||
|
the excellent performance of modern video cards, which turn an X11-based
|
|||
|
Linux box into a fast graphic workstation; nearly always, quicker than
|
|||
|
dedicated machines.
|
|||
|
|
|||
|
I imagine you're a university researcher or a student, and that you use VMS
|
|||
|
for the following everyday tasks:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>writing papers with TeX/LaTeX;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>programming in Fortran;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>doing some graphics;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>using Internet services;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>et cetera.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
In the following sections I'm going to explain to you how to do these tasks
|
|||
|
under Linux, exploiting your experience with VMS. Prerequisites:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Linux and X Window System are properly installed;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>there's a system administrator to take care of the technical details
|
|||
|
(please get help from them, not from me ;-) ;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>your shell---the equivalent of DCL---is bash (ask your sysadm).
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
Please note that this HOWTO is not enough to acquaint you fully with Linux:
|
|||
|
it only contains the bare essential to get you started. You should learn more
|
|||
|
about Linux to make the most of it (advanced bash features, programming,
|
|||
|
regular expressions...). From now on, RMP means `please read the man pages
|
|||
|
for further details'. The man pages are the equivalent of the command HELP.
|
|||
|
|
|||
|
The Linux Documentation Project documents, available on [ftp://
|
|||
|
sunsite.unc.edu:/pub/Linux/docs/LDP] ??, are an important source of
|
|||
|
information. I suggest that you read Larry Greenfield's ``Linux User
|
|||
|
Guide''---it's invaluable for the novice user.
|
|||
|
|
|||
|
And now, go ahead.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
1.2. Comparing Commands and Files
|
|||
|
|
|||
|
This table attempts to compare VMS' and Linux' most used commands. Please
|
|||
|
keep in mind that the syntax is often very different; for more details, refer
|
|||
|
to the following sections.
|
|||
|
|
|||
|
|
|||
|
+-----------------------------------------------------------------------------------+
|
|||
|
|VMS Linux Notes |
|
|||
|
|------------------------------------------------------------------------------ |
|
|||
|
| |
|
|||
|
|@COMMAND command must be executable |
|
|||
|
|COPY file1 file2 cp file1 file2 |
|
|||
|
|CREATE/DIR [.dirname] mkdir dirname only one at a time |
|
|||
|
|CREATE/DIR [.dir1.dir2] mkdirhier dir/name |
|
|||
|
|DELETE filename rm filename |
|
|||
|
|DIFF file1 file2 diff -c file1 file2 |
|
|||
|
|DIRECTORY ls |
|
|||
|
|DIRECTORY [...]file find . -name file |
|
|||
|
|DIRECTORY/FULL ls -al |
|
|||
|
|EDIT filename vi filename, you won't like it |
|
|||
|
| emacs filename, EDT compatible |
|
|||
|
| jed filename ditto---my favourite |
|
|||
|
|FORTRAN prog.for g77 prog.f, no need to do LINK |
|
|||
|
| f77 prog.f, |
|
|||
|
| fort77 prog.f |
|
|||
|
|HELP command man command must specify `command' |
|
|||
|
| info command ditto |
|
|||
|
|LATEX file.tex latex file.tex |
|
|||
|
|LOGIN.COM .bash_profile, `hidden' file |
|
|||
|
| .bashrc ditto |
|
|||
|
|LOGOUT.COM .bash_logout ditto |
|
|||
|
|MAIL mail, crude |
|
|||
|
| elm, much better |
|
|||
|
| pine better still |
|
|||
|
| mutt ditto |
|
|||
|
|PRINT file.ps lpr file.ps |
|
|||
|
|PRINT/QUEUE=laser file.ps lpr -Plaser file.ps |
|
|||
|
|PHONE user talk user |
|
|||
|
|RENAME file1 file2 mv file1 file2 not for multiple files |
|
|||
|
|RUN progname progname |
|
|||
|
|SEARCH file "pattern" grep pattern file |
|
|||
|
|SET DEFAULT [-] cd .. |
|
|||
|
|SET DEFAULT [.dir.name] cd dir/name |
|
|||
|
|SET HOST hostname telnet hostname, not exactly the same |
|
|||
|
| rlogin hostname |
|
|||
|
|SET FILE/OWNER_UIC=joe chown joe file completely different |
|
|||
|
|SET NOBROADCAST mesg |
|
|||
|
|SET PASSWORD passwd |
|
|||
|
|SET PROT=(perm) file chmod perm file completely different |
|
|||
|
|SET TERMINAL export TERM= different syntax |
|
|||
|
|SHOW DEFAULT pwd |
|
|||
|
|SHOW DEVICE du, df |
|
|||
|
|SHOW ENTRY lpq |
|
|||
|
|SHOW PROCESS ps -ax |
|
|||
|
|SHOW QUEUE lpq |
|
|||
|
|SHOW SYSTEM top |
|
|||
|
|SHOW TIME date |
|
|||
|
|SHOW USERS w |
|
|||
|
|STOP kill |
|
|||
|
|STOP/QUEUE kill, for processes |
|
|||
|
| lprm for print queues |
|
|||
|
|SUBMIT command command & |
|
|||
|
|SUBMIT/AFTER=time command at time command |
|
|||
|
|TEX file.tex tex file.tex |
|
|||
|
|TYPE/PAGE file more file |
|
|||
|
| less file much better |
|
|||
|
+-----------------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
But of course it's not only a matter of different command names. Read on.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
2. Short Intro
|
|||
|
|
|||
|
This is what you absolutely need to know before logging in the first time.
|
|||
|
Relax, it's not much.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
2.1. Files
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Under VMS filenames are in the form filename.extension;version. Under
|
|||
|
Linux, the version number doesn't exist (big limitation, but see Section
|
|||
|
Section 10.2); the filename has normally a limit of 255 characters and
|
|||
|
can have as many dots as you like. Example of filename:
|
|||
|
This.is_a_FILEname.txt.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Linux distinguishes between upper case and lower case characters:
|
|||
|
FILENAME.txt and filename.txt are two different files; ls is a command,
|
|||
|
LS is not.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>A filename starting with a dot is a `hidden' file (that is, it won't
|
|||
|
normally show up in dir listings), while filenames ending with a tilde
|
|||
|
'??' represent backup files.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
Now, a table to sum up how to translate commands from VMS to Linux:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|VMS Linux |
|
|||
|
|--------------------------------------------------------------------- |
|
|||
|
| |
|
|||
|
|$ COPY file1.txt file2.txt $ cp file1.txt file2.txt |
|
|||
|
|$ COPY [.dir]file.txt [] $ cp dir/file.txt . |
|
|||
|
|$ COPY [.dir]file.txt [-] $ cp dir/file.txt .. |
|
|||
|
|$ DELETE *.dat;* $ rm *dat |
|
|||
|
|$ DIFF file1 file2 $ diff -c file1 file2 |
|
|||
|
|$ PRINT file $ lpr file |
|
|||
|
|$ PRINT/queue=queuename file $ lpr -Pprintername file |
|
|||
|
|$ SEARCH *.tex;* "geology" $ grep geology *tex |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
For other examples involving directories, see below; for details about
|
|||
|
protections, ownership, and advanced topics, see Section Section 8.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
2.2. Directories
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Within the same node and device, directories names under VMS are in the
|
|||
|
form [top.dir.subdir]; under Linux, /top/dir/subdir/. On the top of the
|
|||
|
directory tree lies the so--called `root directory' called /; underneath
|
|||
|
there are other directories like /bin, /usr, /tmp, /etc, and others.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>The directory /home contains the so--called users' `home directories':
|
|||
|
e.g. /home/guido, /home/warner, and so on. When a user logs in, they
|
|||
|
start working in their home dir; it's the equivalent of SYS$LOGIN.
|
|||
|
There's a shortcut for the home directory: the tilde '??'. So, cd ??/tmp
|
|||
|
is the same as, say, cd /home/guido/tmp.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Directory names follow the same rules as file names. Furthermore, each
|
|||
|
directory has two special entries: one is . and refers to the directory
|
|||
|
itself (like []), and .. that refers to the parent directory (like [-]).
|
|||
|
|
|||
|
|
|||
|
And now for some other examples:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|VMS Linux |
|
|||
|
|--------------------------------------------------------------------- |
|
|||
|
| |
|
|||
|
|$ CREATE/DIR [.dirname] $ mkdir dirname |
|
|||
|
|$ CREATE/DIR [.dir1.dir2.dir3] $ mkdirhier dir1/dir2/dir3 |
|
|||
|
| n/a $ rmdir dirname |
|
|||
|
| (if dirname is empty) |
|
|||
|
| $ rm -R dirname |
|
|||
|
|$ DIRECTORY $ ls |
|
|||
|
|$ DIRECTORY [...]file.*;* $ find . -name "file*" |
|
|||
|
|$ SET DEF SYS$LOGIN $ cd |
|
|||
|
|$ SET DEF [-] $ cd .. |
|
|||
|
|$ SET DEF [top.dir.subdir] $ cd /top/dir/subdir |
|
|||
|
|$ SET DEF [.dir.subdir] $ cd dir/subdir |
|
|||
|
|$ SHOW DEF $ pwd |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
For protections, ownership, and advanced topics, see Section Section 8.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
2.3. Programs
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Commands, compiled programs, and shell scripts (VMS' `command files')
|
|||
|
don't have sort of mandatory extensions like .EXE or .COM and can be
|
|||
|
called whatever you like. Executable files are marked by an asterisk '*'
|
|||
|
when you issue ls -F.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To run an executable file, just type its name (no RUN PROGRAM.EXE or
|
|||
|
@COMMAND). Caveat: it's essential that the file be located in a directory
|
|||
|
included in the path of executables, which is a list of directories.
|
|||
|
Typically, the path includes dirs like /bin, /usr/bin, /usr/X11R6/bin,
|
|||
|
and others. If you write your own programs, put them in a directory you
|
|||
|
have included in the path (see how in Section Section 9). As an
|
|||
|
alternative, you may run a program specifying its complete path: e.g., /
|
|||
|
home/guido/data/myprog; or ./myprog, if the current directory isn't in
|
|||
|
the path.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Command switches are obtained with /OPTION= under VMS, and with -switch
|
|||
|
or --switch under Linux, where switch is a letter, more letters combined,
|
|||
|
or a word. In particular, the switch -R (recursive) of many Linux
|
|||
|
commands performs the same action as [...] under VMS;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>You can issue several commands on the command line:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ command1 ; command2 ; ... ; commandn |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Most of the flexibility of Linux comes from two features awkwardly
|
|||
|
implemented or missing in VMS: I/O redirection and piping. (I have been
|
|||
|
told that recent versions of DCL support redirection and piping, but I
|
|||
|
don't have that version.) Redirection is a side feature under VMS
|
|||
|
(remember the switch /OUTPUT= of many commands), or a fastidious process,
|
|||
|
like:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ DEFINE /USER SYS$OUTPUT OUT |
|
|||
|
|$ DEFINE /USER SYS$INPUT IN |
|
|||
|
|$ RUN PROG |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
which has the simple Linux (UNIX) equivalent:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ prog < in > out |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
Piping is not readily available under VMS, but has a key role under UNIX.
|
|||
|
A typical example:
|
|||
|
+-----------------------------------------------------------------------+
|
|||
|
|$ myprog < datafile | filter_1 | filter_2 >> result.dat 2> errors.log &|
|
|||
|
+-----------------------------------------------------------------------+
|
|||
|
which means: the program myprog gets its input from the file datafile
|
|||
|
(via <), its output is piped (via |) to the program filter_1 that takes
|
|||
|
it as input and processes it, the resulting output is piped again to
|
|||
|
filter_2 for further processing, the final output is appended (via >>) to
|
|||
|
the file result.dat, and error messages are redirected (via 2>) onto the
|
|||
|
file errors.log. All this in background (& at the end of the command
|
|||
|
line). More about this in Section Section 11.
|
|||
|
|
|||
|
|
|||
|
For multitasking, `queues', and the like, see Section Section 8.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
2.4. Quick Tour
|
|||
|
|
|||
|
Now you are ready to try Linux out. Enter your login name and password
|
|||
|
exactly as they are. For example, if your login name and password are john
|
|||
|
and My_PassWd, don't type John or my_passwd. Remember, UNIX distinguishes
|
|||
|
between capital and small letters.
|
|||
|
|
|||
|
Once you've logged in, you'll see a prompt; chances are it'll be something
|
|||
|
like machinename:$. If you want to change the prompt or make some programs
|
|||
|
start automatically, you'll have to edit a `hidden' file called .profile or
|
|||
|
.bash_profile (see example in Section Section 9). This is the equivalent of
|
|||
|
LOGIN.COM.
|
|||
|
|
|||
|
Pressing ALT--F1, ALT--F2, ... ALT--F6 switches between `virtual consoles'.
|
|||
|
When one VC is busy with a full--screen application, you can flip over to
|
|||
|
another and continue to work. Try and log in to another VC.
|
|||
|
|
|||
|
Now you may want to start X Window System (from now on, X). X is a graphic
|
|||
|
environment very similar to DECWindows---actually, the latter derives from
|
|||
|
the former. Type the command startx and wait a few seconds; most likely
|
|||
|
you'll see an open xterm or equivalent terminal emulator, and possibly a
|
|||
|
button bar. (It depends on how your sysadm configured your Linux box.) Click
|
|||
|
on the desktop (try both mouse buttons) to see a menu.
|
|||
|
|
|||
|
While in X, to access the text mode (`console') sessions press CTRL--ALT--F1
|
|||
|
... CTRL--ALT--F6. Try it. When in console, go back to X pressing ALT--F7. To
|
|||
|
quit X, follow the menu instructions or press CTRL--ALT--BS.
|
|||
|
|
|||
|
Type the following command to list your home dir contents, including the
|
|||
|
hidden files:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ ls -al |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Press SHIFT--PAG UP to back-scroll. Now get help about the ls command typing:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ man ls |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
pressing 'q' to exit. To end the tour, type exit to quit your session. If now
|
|||
|
you want to turn off your PC, press CTRL--ALT--DEL and wait a few seconds (
|
|||
|
never switch off the PC while in Linux! You could damage the filesystem.)
|
|||
|
|
|||
|
If you think you're ready to work, go ahead, but if I were you I'd jump to
|
|||
|
Section Section 8.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
3. Editing Files
|
|||
|
|
|||
|
Linux doesn't have EDT, but there are scores of editors available. The only
|
|||
|
one that's guaranteed to be included in every UNIX version is vi---forget it,
|
|||
|
your sysadm must have installed something better. Probably the most popular
|
|||
|
editor is emacs, which can emulate EDT to a certain degree; jed is another
|
|||
|
editor that provides EDT emulation.
|
|||
|
|
|||
|
These two editors are particularly useful for editing program sources, since
|
|||
|
they have two features unknown to EDT: syntax hilighting and automatic
|
|||
|
indentation. Moreover, you can compile your programs from within the editor
|
|||
|
(command ESC-X compile); in case of a syntax error, the cursor will be
|
|||
|
positioned on the offending line. I bet that you'll never want to use the
|
|||
|
true blue EDT again.
|
|||
|
|
|||
|
If you have emacs: start it, then type ESC-X edt-emulation-on. Pressing
|
|||
|
ALT--X or ESC-X is emacs' way of issuing commands, like EDT's CTRL--Z. From
|
|||
|
now on, emacs acts like EDT apart from a few commands. Differences:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>don't press CTRL--Z to issue commands (if you did, you stopped emacs.
|
|||
|
Type fg to resume it);
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>there's an extensive on-line help. Press CTRL-H ?, or CTRL-H T to start a
|
|||
|
tutorial;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to save a file, press CTRL-X CTRL-S;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to exit, press CTRL-X CTRL-C;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to insert a new file in a buffer, press CTRL-X CTRL-F, then CTRL-X B to
|
|||
|
switch among buffers.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
If you have jed: ask your sysadm to configure jed properly. Emulation is
|
|||
|
already on when you start it; use the normal keypad keys, and press CTRL--H
|
|||
|
CTRL--H or CTRL-? to get help. Commands are issued in the same way as emacs'.
|
|||
|
In addition, there are some handy key bindings missing in the original EDT;
|
|||
|
key bindings can also be tailored to your own taste. Ask your sysadm.
|
|||
|
|
|||
|
In alternative, you may use another editor with a completely different
|
|||
|
interface. emacs in native mode is an obvious choice; another popular editor
|
|||
|
is joe, which can emulate other editors like emacs itself (being even easier
|
|||
|
to use) or the DOS editor. Invoke the editor as jmacs or jstar and press,
|
|||
|
respectively, CTRL-X H or CTRL-J to get online help. emacs and jed are much
|
|||
|
more powerful than good ol' EDT.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
4. TeXing
|
|||
|
|
|||
|
TeX and LaTeX are identical to their VMS counterparts---only quicker :-), but
|
|||
|
the tools to handle the .dvi and .ps files are superior:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to run a TeX file through TeX, do as usual: tex file.tex;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to turn a .dvi file into a .ps file, type dvips -o filename.ps
|
|||
|
filename.dvi;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to visualize a .dvi file, type within an X session: xdvi filename.dvi &.
|
|||
|
Click on the page to magnify. This program is smart: if you edit and run
|
|||
|
TeX producing newer versions of the .dvi file, xdvi will update it
|
|||
|
automatically;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to visualize a .ps file, type within an X session: ghostview filename.ps
|
|||
|
&. Click on the page to magnify. The whole document or selected pages can
|
|||
|
be printed. A newer and better program is gv.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>to print the .ps: usually the command lpr mypaper.ps will do, but if the
|
|||
|
PostScript printer is called, say, `ps' (ask your sysadm) you'll do: lpr
|
|||
|
-Pps mypaper.ps. For more information about print queues, go to Section
|
|||
|
Section 8.4.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
5. Programming
|
|||
|
|
|||
|
Programming under Linux is much better: there are lots of tools that make
|
|||
|
programming easier and quicker. For instance, the drudgery of
|
|||
|
editing--saving--exiting--compiling--re-editing can be cut short by using
|
|||
|
editors like emacs or jed, as seen above.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
5.1. Fortran
|
|||
|
|
|||
|
Not substantial differences here, but note that at the time of writing the
|
|||
|
available (free) compilers are not 100% compatible with VMS'; expect some
|
|||
|
minor quirks. (It's actually the VMS compiler which has non-standard
|
|||
|
extensions.) See /usr/doc/g77/DOC or /usr/doc/f2c/f2c.ps for details.
|
|||
|
|
|||
|
Your sysadm has installed a native compiler called g77 (good but, as of
|
|||
|
version 0.5.21, still not perfectly compatible with DEC Fortran) or possibly
|
|||
|
the Fortran to C translator, f2c, and one of the front-ends that make it
|
|||
|
mimic a native compiler. In my experience, the package yaf77 is the one that
|
|||
|
provides best results.
|
|||
|
|
|||
|
To compile a Fortran program with g77, edit the source, save it with
|
|||
|
extension .f, then do:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ g77 myprog.f |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
which creates by default an executable called a.out (you don't have to link
|
|||
|
anything). To give the executable a different name and do some optimisation:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ g77 -O2 -o myprog myprog.f |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Beware of optimisations! Ask your sysadm to read the documentation that comes
|
|||
|
with the compiler and tell you if there are any problems.
|
|||
|
|
|||
|
To compile a subroutine:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ g77 -c mysub.f |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
This creates a file mysub.o. To link this subroutine to a program, you'll do
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ g77 -o myprog myprog.f mysub.o |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
If you have many external subroutines and you want to make a library, do the
|
|||
|
following:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ cd subroutines/ |
|
|||
|
|$ cat *f >mylib.f ; g77 -c mylib.f |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
This will create mylib.o that you can link to your programs.
|
|||
|
|
|||
|
Finally, to link an external library called, say, libdummy.so:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ g77 -o myprog myprog.f -ldummy |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
If you have f2c, you only have to use f77 or fort77 instead of g77.
|
|||
|
|
|||
|
Another useful programming tool is make, described below.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
5.2. Using make
|
|||
|
|
|||
|
The utility make is a tool to handle the compilation of programs that are
|
|||
|
split into several source files. The VMS counterparts are MMS and MMK, which
|
|||
|
have a different syntax.
|
|||
|
|
|||
|
Let's suppose you have source files containing your routines, file_1.f,
|
|||
|
file_2.f, file_3.f, and a source file of the main program that uses the
|
|||
|
routines, myprog.f. If you compile your program manually, whenever you modify
|
|||
|
one of the source files you have to figure out which file depends on which,
|
|||
|
which file to recompile first, and so on.
|
|||
|
|
|||
|
Instead of getting mad, you can write a `makefile'. This is a text file
|
|||
|
containing the dependencies between your sources: when one is modified, only
|
|||
|
the ones that depend on the modified file will be recompiled.
|
|||
|
|
|||
|
In our example, you'd write a makefile like this:
|
|||
|
|
|||
|
|
|||
|
# This is makefile
|
|||
|
# Press the <TAB> key where you see <TAB>!
|
|||
|
# It's important: don't use spaces instead.
|
|||
|
|
|||
|
myprog: myprog.o file_1.o file_2.o file_3.o
|
|||
|
<TAB>g77 -o myprog myprog.o file_1.o file_2.o file_3.o
|
|||
|
# myprog depends on four object files
|
|||
|
|
|||
|
myprog.o: myprog.f
|
|||
|
<TAB>g77 -c myprog.f
|
|||
|
# myprog.o depends on its source file
|
|||
|
|
|||
|
file_1.o: file_1.f
|
|||
|
<TAB>g77 -c file_1.f
|
|||
|
# file_1.o depends on its source file
|
|||
|
|
|||
|
file_2.o: file_2.f file_1.o
|
|||
|
<TAB>g77 -c file_2.f file_1.o
|
|||
|
# file_2.o depends on its source file and an object file
|
|||
|
|
|||
|
file_3.o: file_3.f file_2.o
|
|||
|
<TAB>g77 -c file_3.f file_2.o
|
|||
|
# file_3.o depends on its source file and an object file
|
|||
|
|
|||
|
# end of makefile.
|
|||
|
|
|||
|
|
|||
|
Save this file as Makefile and type make to compile your program;
|
|||
|
alternatively, save it as myprog.mak and type make -f myprog.mak. And of
|
|||
|
course, RMP.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
5.3. Shell Scripts
|
|||
|
|
|||
|
Shell scripts are the equivalent of VMS' command files, and allow for very
|
|||
|
powerful constructs.
|
|||
|
|
|||
|
To write a script, all you have to do is write a standard ASCII file
|
|||
|
containing the commands, save it, then make it executable with the command
|
|||
|
chmod +x <scriptfile>. To execute it, type its name.
|
|||
|
|
|||
|
Writing scripts under bash is such a vast subject it would require a book by
|
|||
|
itself, and I will not delve into the topic any further. I'll just give you a
|
|||
|
more-or-less comprehensive and (hopefully) useful example you can extract
|
|||
|
some basic rules from.
|
|||
|
|
|||
|
EXAMPLE: sample.sh
|
|||
|
|
|||
|
|
|||
|
#!/bin/sh
|
|||
|
# sample.sh
|
|||
|
# I am a comment
|
|||
|
# don't change the first line, it must be there
|
|||
|
echo "This system is: `uname -a`" # use the output of the command
|
|||
|
echo "My name is $0" # built-in variables
|
|||
|
echo "You gave me the following $# parameters: "$*
|
|||
|
echo "First parameter is: "$1
|
|||
|
echo -n "What's your name? " ; read your_name
|
|||
|
echo notice the difference: "hi $your_name" # quoting with "
|
|||
|
echo notice the difference: 'hi $your_name' # quoting with '
|
|||
|
DIRS=0 ; FILES=0
|
|||
|
for file in `ls .` ; do
|
|||
|
if [ -d ${file} ] ; then # if file is a directory
|
|||
|
DIRS=`expr $DIRS + 1` # this means DIRS = DIRS + 1
|
|||
|
elif [ -f ${file} ] ; then
|
|||
|
FILES=`expr $FILES + 1`
|
|||
|
fi
|
|||
|
case ${file} in
|
|||
|
*.gif|*jpg) echo "${file}: graphic file" ;;
|
|||
|
*.txt|*.tex) echo "${file}: text file" ;;
|
|||
|
*.c|*.f|*.for) echo "${file}: source file" ;;
|
|||
|
*) echo "${file}: generic file" ;;
|
|||
|
esac
|
|||
|
done
|
|||
|
echo "there are ${DIRS} directories and ${FILES} files"
|
|||
|
ls | grep "ZxY--!!!WKW"
|
|||
|
if [ $? != 0 ] ; then # exit code of last command
|
|||
|
echo "ZxY--!!!WKW not found"
|
|||
|
fi
|
|||
|
echo "enough... type 'man bash' if you want more info."
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
5.4. C
|
|||
|
|
|||
|
Linux is an excellent environment to program in C. Taken for granted that you
|
|||
|
know C, here are a couple of guidelines. To compile your standard hello.c
|
|||
|
you'll use the gcc compiler, which comes as part of Linux and has the same
|
|||
|
syntax as g77:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ gcc -O2 -o hello hello.c |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To link a library to a program, add the switch -l<libname>. For example, to
|
|||
|
link the math library and optimize do
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ gcc -O2 -o mathprog mathprog.c -lm |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
(The -l<libname> switch forces gcc to link the library /usr/lib/lib<libname
|
|||
|
>.a; so -lm links /usr/lib/libm.a).
|
|||
|
|
|||
|
When your program is made of several source files, you'll need to use the
|
|||
|
utility make described above. Just use gcc and C source files in the
|
|||
|
makefile.
|
|||
|
|
|||
|
You can invoke some help about the C functions, that are covered by man
|
|||
|
pages, section 3; for example,
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ man 3 printf |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
There are lots of libraries available out there; among the first you'll want
|
|||
|
to use are ncurses, to handle text mode effects, and svgalib, to do graphics.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
6. Graphics
|
|||
|
|
|||
|
Among the scores of graphic packages available, gnuplot stands out for its
|
|||
|
power and ease of use. Go to X and type gnuplot, and have two sample data
|
|||
|
files ready: 2D-data.dat (two data per line), and 3D-data.dat (three data per
|
|||
|
line).
|
|||
|
|
|||
|
Examples of 2-D graphs:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|gnuplot> set title "my first graph" |
|
|||
|
|gnuplot> plot '2D-data.dat' |
|
|||
|
|gnuplot> plot '2D-data.dat' with linespoints |
|
|||
|
|gnuplot> plot '2D-data.dat', sin(x) |
|
|||
|
|gnuplot> plot [-5:10] '2D-data.dat' |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Example of 3-D graphs (each `row' of X values is followed by a blank line):
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|gnuplot> set parametric ; set hidden3d ; set contour |
|
|||
|
|gnuplot> splot '3D-data.dat' using 1:2:3 with linespoints |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
A single-column datafile (e.g., a time series) can also be plotted as a 2-D
|
|||
|
graph:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|gnuplot> plot [-5:15] '2D-data-1col.dat' with linespoints |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
or as a 3-D graph (blank lines in the datafile, as above):
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|gnuplot> set noparametric ; set hidden3d |
|
|||
|
|gnuplot> splot '3D-data-1col.dat' using 1 with linespoints |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To print a graph: if the command to print on your Postscript printer is lpr
|
|||
|
-Pps file.ps, issue:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|gnuplot> set term post |
|
|||
|
|gnuplot> set out '| lpr -Pps' |
|
|||
|
|gnuplot> replot |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
then type set term x11 to restore. Don't get confused---the last print will
|
|||
|
come out only when you quit gnuplot.
|
|||
|
|
|||
|
For more info, type help or see the examples in directory /usr/lib/gnuplot/
|
|||
|
demos/, if you have it.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
7. Mail and Internet Tools
|
|||
|
|
|||
|
Since Internet was born on UNIX machines, you find plenty of nice and
|
|||
|
easy-to-use applications under Linux. Here are just some:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Mail: use elm or pine to handle your email; both programs have on-line
|
|||
|
help. For short messages, you could use mail, as in mail -s "hello mate"
|
|||
|
user@somewhere < msg.txt. You may like programs like xmail or some such.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Newsgroups: use tin or slrn, both very intuitive and self-explanatory.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>ftp: apart from the usual character-based ftp, ask your sysadm to install
|
|||
|
the full-screen ncftp or a graphical ftp client like xftp.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>WWW: the ubiquitous netscape, or xmosaic, chimera, and arena are
|
|||
|
graphical web browsers; a character-based one is lynx, quick and
|
|||
|
effective.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
8. Advanced Topics
|
|||
|
|
|||
|
Here the game gets tough. Learn these features, then you'll be ready to say
|
|||
|
that you `know something about Linux' ;-)
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
8.1. Permissions and Ownership
|
|||
|
|
|||
|
Files and directories have permissions (`protections') and ownership, just
|
|||
|
like under VMS. If you can't run a program, or can't modify a file, or can't
|
|||
|
access a directory, it's because you don't have the permission to do so, and/
|
|||
|
or because the file doesn't belong to you. Let's have a look at the following
|
|||
|
example:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ ls -l /bin/ls |
|
|||
|
|-rwxr-xr-x 1 root bin 27281 Aug 15 1995 /bin/ls* |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
The first field shows the permissions of the file ls (owner root, group bin).
|
|||
|
There are three types of ownership: owner, group, and others (similar to VMS
|
|||
|
owner, group, world), and three types of permissions: read, write (and
|
|||
|
delete), and execute.
|
|||
|
|
|||
|
From left to right, - is the file type (- = ordinary file, d = directory, l =
|
|||
|
link, etc); rwx are the permissions for the file owner (read, write,
|
|||
|
execute); r-x are the permissions for the group of the file owner (read,
|
|||
|
execute); r-x are the permissions for all other users (read, execute).
|
|||
|
|
|||
|
To change a file's permissions:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ chmod <whoXperm> <file> |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
where who is u (user, that is owner), g (group), o (other), X is either + or
|
|||
|
-, perm is r (read), w (write), or x (execute). Examples:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ chmod u+x file |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
this sets the execute permission for the file owner. Shortcut: chmod +x file.
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ chmod go-wx file |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
this removes write and execute permission for everyone except the owner.
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ chmod ugo+rwx file |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
this gives everyone read, write, and execute permission.
|
|||
|
|
|||
|
A shorter way to refer to permissions is with numbers: rwxr-xr-x can be
|
|||
|
expressed as 755 (every letter corresponds to a bit: --- is 0, --x is 1, -w-
|
|||
|
is 2...).
|
|||
|
|
|||
|
For a directory, rx means that you can cd to that directory, and w means that
|
|||
|
you can delete a file in the directory (according to the file's permissions,
|
|||
|
of course), or the directory itself. All this is only part of the
|
|||
|
matter---RMP.
|
|||
|
|
|||
|
To change a file's owner:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ chown username file |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To sum up, a table:
|
|||
|
|
|||
|
|
|||
|
+-------------------------------------------------------------------------------+
|
|||
|
|VMS Linux Notes |
|
|||
|
|------------------------------------------------------------------------------ |
|
|||
|
| |
|
|||
|
|SET PROT=(O:RW) file.txt $ chmod u+rw file.txt |
|
|||
|
| $ chmod 600 file.txt |
|
|||
|
|SET PROT=(O:RWED,W) file $ chmod u+rwx file |
|
|||
|
| $ chmod 700 file |
|
|||
|
|SET PROT=(O:RWED,W:RE) file $ chmod 755 file |
|
|||
|
|SET PROT=(O:RW,G:RW,W) file $ chmod 660 file |
|
|||
|
|SET FILE/OWNER_UIC=JOE file $ chown joe file |
|
|||
|
|SET DIR/OWNER_UIC=JOE [.dir] $ chown joe dir/ |
|
|||
|
+-------------------------------------------------------------------------------+
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
8.2. Multitasking: Processes and Jobs
|
|||
|
|
|||
|
More about running programs. There are no `batch queues' under Linux as
|
|||
|
you're used to; multitasking is handled very differently. Again, this is what
|
|||
|
the typical command line looks like:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ command -s1 -s2 ... -sn par1 par2 ... parn < input > output & |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
where -s1, ..., -sn are the program switches, par1, ..., parn are the program
|
|||
|
parameters.
|
|||
|
|
|||
|
Now let's see how multitasking works. Programs, running in foreground or
|
|||
|
background, are called `processes'.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To launch a process in background:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ progname [-switches] [parameters] [< input] [> output] & |
|
|||
|
|[1] 234 |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
the shell tells you what the `job number' (the first digit; see below)
|
|||
|
and PID (Process IDentifier) of the process are. Each process is
|
|||
|
identified by its PID.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To see how many processes there are:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ ps -ax |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
This will output a list of currently running processes.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To kill a process:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ kill <PID> |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
You may need to kill a process when you don't know how to quit it the
|
|||
|
right way... ;-). Sometimes, a process will only be killed by one of the
|
|||
|
following:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ kill -15 <PID> |
|
|||
|
|$ kill -9 <PID> |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
In addition to this, the shell allows you to stop or temporarily suspend a
|
|||
|
process, send a process to background, and bring a process from background to
|
|||
|
foreground. In this context, processes are called `jobs'.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To see how many jobs there are:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ jobs |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
jobs are identified by the numbers the shell gives them, not by their
|
|||
|
PID.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To stop a process running in foreground:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ CTRL-C |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
(it doesn't always work)
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To suspend a process running in foreground:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ CTRL-Z |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
(ditto)
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To send a suspended process into background (it becomes a job):
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ bg <job> |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To bring a job to foreground:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ fg <job> |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>To kill a job:
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|$ kill <%job> |
|
|||
|
+---------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
8.3. Files, Revisited
|
|||
|
|
|||
|
More information about files.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>stdin, stdout, stderr: under UNIX, every system component is treated as
|
|||
|
if it were a file. Commands and programs get their input from a `file'
|
|||
|
called stdin (standard input; usually, the keyboard), put their output on
|
|||
|
a `file' called stdout (usually, the screen), and error messages go to a
|
|||
|
`file' called stderr (usually, the screen). Using < and > you redirect
|
|||
|
input and output to a different file. Moreover, >> appends the output to
|
|||
|
a file instead of overwriting it; 2> redirects error messages (stderr); 2
|
|||
|
>&1 redirects stderr to stdout, while 1>&2 redirects stdout to stderr.
|
|||
|
There's a `black hole' called /dev/null: everything redirected to it
|
|||
|
disappears;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>wildcards: '*' is almost the same. Usage: * matches all files except the
|
|||
|
hidden ones; .* matches all hidden files; *.* matches only those that
|
|||
|
have a '.' in the middle, followed by other characters; p*r matches both
|
|||
|
`peter' and `piper'; *c* matches both `picked' and `peck'. '%' becomes '?
|
|||
|
'. There is another wildcard: the []. Usage: [abc]* matches files
|
|||
|
starting with a, b, c; *[I-N,1,2,3] matches files ending with I, J, K, L,
|
|||
|
M, N, 1, 2, 3;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>mv (RENAME) doesn't work for multiple files; that is, mv *.xxx *.yyy
|
|||
|
won't work;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>use cp -i and mv -i to be warned when a file is going to be overwritten.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
8.4. Print Queues
|
|||
|
|
|||
|
Your prints are queued, like under VMS. When you issue a print command, you
|
|||
|
may specify a printer name. Example:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ lpr file.txt # this goes to the standard printer |
|
|||
|
|$ lpr -Plaser file.ps # this goes to the printer named 'laser' |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To handle the print queues, you use the following commands:
|
|||
|
|
|||
|
|
|||
|
+-------------------------------------------------------------------------------+
|
|||
|
|VMS Linux |
|
|||
|
|------------------------------------------------------------------------------ |
|
|||
|
| |
|
|||
|
|$ PRINT file.ps $ lpr file.ps |
|
|||
|
|$ PRINT/QUEUE=laser file.ps $ lpr -Plaser file.ps |
|
|||
|
|$ SHOW QUEUE $ lpq |
|
|||
|
|$ SHOW QUEUE/QUEUE=laser $ lpq -Plaser |
|
|||
|
|$ STOP/QUEUE $ lprm <item> |
|
|||
|
+-------------------------------------------------------------------------------+
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
9. Configuring
|
|||
|
|
|||
|
Your sysadm has already provided you with a number of configuration files
|
|||
|
like .xinitrc, .bash_profile, .inputrc, and many others. The ones you may
|
|||
|
want to edit are:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>.bash_profile or .profile: read by the shell at login time. It's like
|
|||
|
LOGIN.COM;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>.bash_logout: read by the shell at logout. It's like LOGOUT.COM;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>.bashrc: read by non--login shells.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>.inputrc: this file customises the key bindings and the behaviour of the
|
|||
|
shell.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
To give you an example, I'll include my .bash_profile (abridged):
|
|||
|
|
|||
|
|
|||
|
# $HOME/.bash_profile
|
|||
|
|
|||
|
# don't redefine the path if not necessary
|
|||
|
echo $PATH | grep $LOGNAME > /dev/null
|
|||
|
if [ $? != 0 ]
|
|||
|
then
|
|||
|
export PATH="$PATH:/home/$LOGNAME/bin" # add my dir to the PATH
|
|||
|
fi
|
|||
|
|
|||
|
export PS1='LOGNAME:\w\$ '
|
|||
|
export PS2='Continued...>'
|
|||
|
|
|||
|
# aliases
|
|||
|
|
|||
|
alias bin="cd ~/bin" ; alias cp="cp -i" ; alias d="dir"
|
|||
|
alias del="delete" ; alias dir="/bin/ls $LS_OPTIONS --format=vertical"
|
|||
|
alias ed="jed" ; alias mv='mv -i'
|
|||
|
alias u="cd .." ; alias undel="undelete"
|
|||
|
|
|||
|
# A few useful functions
|
|||
|
|
|||
|
inst() # Install a .tar.gz archive in current directory.
|
|||
|
{
|
|||
|
gzip -dc $1 | tar xvf -
|
|||
|
}
|
|||
|
cz() # List the contents of a .zip archive.
|
|||
|
{
|
|||
|
unzip -l $*
|
|||
|
}
|
|||
|
ctgz() # List the contents of a .tar.gz archive.
|
|||
|
{
|
|||
|
for file in $* ; do
|
|||
|
gzip -dc ${file} | tar tf -
|
|||
|
done
|
|||
|
}
|
|||
|
tgz() # Create a .tgz archive a la zip.
|
|||
|
{
|
|||
|
name=$1 ; tar -cvf $1 ; shift
|
|||
|
tar -rf ${name} $* ; gzip -S .tgz ${name}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
And this is my .inputrc:
|
|||
|
|
|||
|
|
|||
|
# $HOME/.inputrc
|
|||
|
# Last modified: 16 January 1997.
|
|||
|
#
|
|||
|
# This file is read by bash and defines key bindings to be used by the shell;
|
|||
|
# what follows fixes the keys END, HOME, and DELETE, plus accented letters.
|
|||
|
# For more information, man readline.
|
|||
|
|
|||
|
"\e[1~": beginning-of-line
|
|||
|
"\e[3~": delete-char
|
|||
|
"\e[4~": end-of-line
|
|||
|
|
|||
|
set bell-style visible
|
|||
|
set meta-flag On
|
|||
|
set convert-meta Off
|
|||
|
set output-meta On
|
|||
|
set horizontal-scroll-mode On
|
|||
|
set show-all-if-ambiguous On
|
|||
|
|
|||
|
# (F1 .. F5) are "\e[[A" ... "\e[[E"
|
|||
|
|
|||
|
"\e[[A": "info "
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
10. Useful Programs
|
|||
|
|
|||
|
10.1. Browsing Files: less
|
|||
|
|
|||
|
You'll use this file browser every day, so I'll give you a couple of tips to
|
|||
|
use it at best. First of all, ask your sysadm to configure less so as it can
|
|||
|
display not only plain text files, but also compressed files, archives, and
|
|||
|
so on.
|
|||
|
|
|||
|
Like recent versions of TYPE, less lets you browse files in both directions.
|
|||
|
It also accepts several commands that are issued pressing a key. The most
|
|||
|
useful are:
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>first of all, press q to leave the browser;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>h gives you extensive help;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>g to go to beginning of file, G to the end, number+g to go to line
|
|||
|
`number' (e.g. 125g), number+% to move to that percentage of the file;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>/pattern searches forwards for `pattern'; n searches forwards for the
|
|||
|
next match; ?pattern and N search backwards;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>m+letter marks current position (e.g. ma); '+letter go to the marked
|
|||
|
position.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>:e examines a new file;
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>!command executes the shell command.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
10.2. Numbered Backups Under Linux
|
|||
|
|
|||
|
Alas, Linux doesn't still support file version numbers, but you overcome this
|
|||
|
limitation in two ways. The first is to use RCS, the Revision Control System,
|
|||
|
which allows you to keep previous versions of a file. RCS is covered in ``The
|
|||
|
RCS MINI-HOWTO'' ([http://sunsite.unc.edu/mdw/HOWTO/mini/RCS.html] ??).
|
|||
|
|
|||
|
The second way is to use an editor that knows how to deal with numbered
|
|||
|
backups; emacs and jed are OK. In emacs, add these lines in your .emacs:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|(setq version-control t) |
|
|||
|
|(setq kept-new-versions 15) ;;; or any other value |
|
|||
|
|(setq kept-old-versions 15) |
|
|||
|
|(setq backup-by-copying-when-linked t) |
|
|||
|
|(setq backup-by-copying-when-mismatch t) |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
In jed, make sure you have version 0.98.7 or newer; the patch for numbered
|
|||
|
backups is available on [http://ibogeo.df.unibo.it/guido/slang/backups.sl] ??
|
|||
|
.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
10.3. Archiving: tar & gzip
|
|||
|
|
|||
|
Under UNIX there are some widely used applications to archive and compress
|
|||
|
files. tar is used to make archives, that is collections of files. To make a
|
|||
|
new archive:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ tar -cvf <archive_name.tar> <file> [file...] |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To extract files from an archive:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ tar -xpvf <archive_name.tar> [file...] |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To list the contents of an archive:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ tar -tf <archive_name.tar> | less |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Files can be compressed to save disk space using compress, which is obsolete
|
|||
|
and shouldn't be used any more, or gzip:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ compress <file> |
|
|||
|
|$ gzip <file> |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
that creates a compressed file with extension .Z (compress) or .gz (gzip).
|
|||
|
These programs don't make archives, but compress files individually. To
|
|||
|
decompress, use:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ compress -d <file.Z> |
|
|||
|
|$ gzip -d <file.gz> |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
RMP.
|
|||
|
|
|||
|
The unarj, zip and unzip utilities are also available. Files with extension
|
|||
|
.tar.gz or .tgz (archived with tar, then compressed with gzip) are very
|
|||
|
common in the UNIX world. Here's how to list the contents of a .tar.gz
|
|||
|
archive:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ tar -ztf <file.tar.gz> | less |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
To extract the files from a .tar.gz archive:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ tar -zxf <file.tar.gz> |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
11. Real Life Examples
|
|||
|
|
|||
|
UNIX' core idea is that there are many simple commands that can linked
|
|||
|
together via piping and redirection to accomplish even really complex tasks.
|
|||
|
Have a look at the following examples. I'll only explain the most complex
|
|||
|
ones; for the others, please study the above sections and the man pages.
|
|||
|
|
|||
|
Problem: ls is too quick and the file names fly away.
|
|||
|
|
|||
|
Solution:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ ls | less |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Problem: I have a file containing a list of words. I want to sort it in
|
|||
|
reverse order and print it.
|
|||
|
|
|||
|
Solution:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ cat myfile.txt | sort -r | lpr |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Problem: my data file has some repeated lines! How do I get rid of them?
|
|||
|
|
|||
|
Solution:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ sort datafile.dat | uniq > newfile.dat |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Problem: I have a file called 'mypaper.txt' or 'mypaper.tex' or some such
|
|||
|
somewhere, but I don't remember where I put it. How do I find it?
|
|||
|
|
|||
|
Solution:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ find ~ -name "mypaper*" |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Explanation: find is a very useful command that lists all the files in a
|
|||
|
directory tree (starting from ?? in this case). Its output can be filtered to
|
|||
|
meet several criteria, such as -name.
|
|||
|
|
|||
|
Problem: I have a text file containing the word 'entropy' in this directory,
|
|||
|
is there anything like SEARCH?
|
|||
|
|
|||
|
Solution: yes, try
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ grep -l 'entropy' * |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Problem: somewhere I have text files containing the word 'entropy', I'd like
|
|||
|
to know which and where they are. Under VMS I'd use search entropy [...]*.*;
|
|||
|
*, but grep can't recurse subdirectories. Now what?
|
|||
|
|
|||
|
Solution:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ find . -exec grep -l "entropy" {} \; 2> /dev/null |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Explanation: find . outputs all the file names starting from the current
|
|||
|
directory, -exec grep -l "entropy" is an action to be performed on each file
|
|||
|
(represented by {}), \ terminates the command. If you think this syntax is
|
|||
|
awful, you're right.
|
|||
|
|
|||
|
In alternative, write the following script:
|
|||
|
|
|||
|
|
|||
|
#!/bin/sh
|
|||
|
# rgrep: recursive grep
|
|||
|
if [ $# != 3 ]
|
|||
|
then
|
|||
|
echo "Usage: rgrep --switches 'pattern' 'directory'"
|
|||
|
exit 1
|
|||
|
fi
|
|||
|
find $3 -name "*" -exec grep $1 $2 {} \; 2> /dev/null
|
|||
|
|
|||
|
|
|||
|
Explanation: grep works like search, and combining it with find we get the
|
|||
|
best of both worlds.
|
|||
|
|
|||
|
Problem: I have a data file that has two header lines, then every line has
|
|||
|
'n' data, not necessarily equally spaced. I want the 2nd and 5th data value
|
|||
|
of each line. Shall I write a Fortran program...?
|
|||
|
|
|||
|
Solution: nope. This is quicker:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ awk 'NL > 2 {print $2, "\t", $5}' datafile.dat > newfile.dat |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Explanation: the command awk is actually a programming language: for each
|
|||
|
line starting from the third in datafile.dat, print out the second and fifth
|
|||
|
field, separated by a tab. Learn some awk---it saves a lot of time.
|
|||
|
|
|||
|
Problem: I've downloaded an FTP site's ls-lR.gz to check its contents. For
|
|||
|
each subdirectory, it contains a line that reads "total xxxx", where xxxx is
|
|||
|
size in kbytes of the dir contents. I'd like to get the grand total of all
|
|||
|
these xxxx values.
|
|||
|
|
|||
|
Solution:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|$ zcat ls-lR.gz | awk ' $1 == "total" { i += $2 } END {print i}' |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Explanation: zcat outputs the contents of the .gz file and pipes to awk,
|
|||
|
whose man page you're kindly requested to read ;-)
|
|||
|
|
|||
|
Problem: I've written a Fortran program, myprog, to calculate a parameter
|
|||
|
from a data file. I'd like to run it on hundreds of data files and have a
|
|||
|
list of the results, but it's a nuisance to ask each time for the file name.
|
|||
|
Under VMS I'd write a lengthy command file, and under Linux?
|
|||
|
|
|||
|
Solution: a very short script. Make your program look for the data file
|
|||
|
'mydata.dat' and print the result on the screen (stdout), then write the
|
|||
|
following script:
|
|||
|
|
|||
|
|
|||
|
#!/bin/sh
|
|||
|
# myprog.sh: run the same command on many different files
|
|||
|
# usage: myprog.sh *.dat
|
|||
|
for file in $* # for all parameters (e.g. *.dat)
|
|||
|
do
|
|||
|
# append the file name to result.dat
|
|||
|
echo -n "${file}: " >> results.dat
|
|||
|
# copy current argument to mydata.dat, run myprog
|
|||
|
# and append the output to results.dat
|
|||
|
cp ${file} mydata.dat ; myprog >> results.dat
|
|||
|
done
|
|||
|
|
|||
|
|
|||
|
Problem: I want to replace `geology' with `geophysics' in all my text files.
|
|||
|
Shall I edit them all manually?
|
|||
|
|
|||
|
Solution: nope. Write this shell script:
|
|||
|
|
|||
|
|
|||
|
#!/bin/sh
|
|||
|
# replace $1 with $2 in $*
|
|||
|
# usage: replace "old-pattern" "new-pattern" file [file...]
|
|||
|
OLD=$1 # first parameter of the script
|
|||
|
NEW=$2 # second parameter
|
|||
|
shift ; shift # discard the first 2 parameters: the next are the file names
|
|||
|
for file in $* # for all files given as parameters
|
|||
|
do
|
|||
|
# replace every occurrence of OLD with NEW, save on a temporary file
|
|||
|
sed "s/$OLD/$NEW/g" ${file} > ${file}.new
|
|||
|
# rename the temporary file as the original file
|
|||
|
/bin/mv ${file}.new ${file}
|
|||
|
done
|
|||
|
|
|||
|
|
|||
|
Problem: I have some data files, I don't know their length and have to remove
|
|||
|
their last but one and last but two lines. Er... manually?
|
|||
|
|
|||
|
Solution: no, of course. Write this script:
|
|||
|
|
|||
|
|
|||
|
#!/bin/sh
|
|||
|
# prune.sh: removes n-1th and n-2th lines from files
|
|||
|
# usage: prune.sh file [file...]
|
|||
|
for file in $* # for every parameter
|
|||
|
do
|
|||
|
LINES=`wc -l $file | awk '{print $1}'` # number of lines in file
|
|||
|
LINES=`expr $LINES - 3` # LINES = LINES - 3
|
|||
|
head -n $LINES $file > $file.new # output first LINES lines
|
|||
|
tail -n 1 $file >> $file.new # append last line
|
|||
|
done
|
|||
|
|
|||
|
|
|||
|
I hope these examples whetted your appetite...
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
12. Tips You Can't Do Without
|
|||
|
|
|||
|
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Command completion: pressing <TAB> when issuing a command will complete
|
|||
|
the command line for you. Example: you have to type less
|
|||
|
this_is_a_long_name; typing in less thi<TAB> will suffice. (If you have
|
|||
|
other files that start with the same characters, supply enough characters
|
|||
|
to resolve any ambiguity.)
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Back-scrolling: pressing SHIFT--PAG UP (the grey key) allows you to
|
|||
|
backscroll a few pages, depending on your PC's video memory.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Resetting the screen: if you happen to more or cat a binary file, your
|
|||
|
screen may end up full of garbage. To fix things, blind type reset or
|
|||
|
this sequence of characters: echo CTRL-V ESC c RETURN.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Pasting text: in console, see below; in X, click and drag to select the
|
|||
|
text in an xterm window, then click the middle button (or the two buttons
|
|||
|
together if you have a two-button mouse) to paste.
|
|||
|
|
|||
|
<EFBFBD><EFBFBD>*<2A>Using the mouse: ask your sysadm to install gpm, a mouse driver for the
|
|||
|
console. Click and drag to select text, then right click to paste the
|
|||
|
selected text. It works across different VCs.
|
|||
|
|
|||
|
|
|||
|
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
13. Reading VMS tapes from Linux
|
|||
|
|
|||
|
(This section was written by Mike Miller)
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
13.1. Introduction
|
|||
|
|
|||
|
From time to time you may want to read tapes made on a VMS machine (or tapes
|
|||
|
that are made to be readable by VMS and *nix systems). In general, this is
|
|||
|
quite easy for DECFILES11A tapes.
|
|||
|
|
|||
|
Although you may be reading this as part of a Linux mini-HOWTO, I believe
|
|||
|
that the information here is applicable to any *nix system - I've done this
|
|||
|
on Linux, HP, Sun and DEC *nix systems. The main platform dependences that I
|
|||
|
know are device names, which can differ on different systems, and the options
|
|||
|
to mt for specifying the device name (for example, mt -f on Linux and mt -t
|
|||
|
on HPUX 9).
|
|||
|
|
|||
|
Caveat - I've only tried this with Exabyte 8mm SCSI tape drives. If you've
|
|||
|
read other formats (still got those 9-tracks lying around?) let me know and
|
|||
|
I'll add a note here.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
13.2. The Basics
|
|||
|
|
|||
|
When reading a tape that has been made with the VMS ``copy'' command (or has
|
|||
|
at least been made to look like it was made with copy) all you need to know
|
|||
|
is there will be three files on the tape for each actual data file - a
|
|||
|
header, the data, and a trailer. The header and trailer are interesting in
|
|||
|
that they contain info on the file as it existed under VMS. The data is,
|
|||
|
well, the data. Each of these files can be extracted from the tape with the
|
|||
|
dd command. The tape can be positioned by skipping around with the mt
|
|||
|
command.
|
|||
|
|
|||
|
Example: I've got VMS tape with a series of files on it. The first two were
|
|||
|
originally named ce66-2.evt and ce66-3.evt on a VMS system. The tape label is
|
|||
|
c66a2.
|
|||
|
|
|||
|
If I execute these commands:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|> dd if=$TAPE bs=16k of=header1 |
|
|||
|
|> dd if=$TAPE bs=16k of=data1 |
|
|||
|
|> dd if=$TAPE bs=16k of=trailer1 |
|
|||
|
|> dd if=$TAPE bs=16k of=header2 |
|
|||
|
|> dd if=$TAPE bs=16k of=data2 |
|
|||
|
|> dd if=$TAPE bs=16k of=trailer2 |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
I'm left with six files: header1, data1, trailer1, header2, data2 and
|
|||
|
trailer2. The syntax here is if="input file", bs="block size" and of="output
|
|||
|
file". TAPE is expected to be a variable containing the device name of your
|
|||
|
tape drive - for example, /dev/nts0 if you are using the first SCSI tape on
|
|||
|
Linux.
|
|||
|
|
|||
|
If you wanted to read the second file, but not the first, you didn't care
|
|||
|
about the header, and you wanted to use the original file name, do this:
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|> mt -f $TAPE fsf 4 |
|
|||
|
|> dd if=$TAPE bs=16k of=ce66-2.evt |
|
|||
|
|> mt -f $TAPE fsf 1 |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
Note the 4 - skip three files for the first file on the tape and one for the
|
|||
|
next header. The second mt skips the second file's trailer and positions the
|
|||
|
tape at the beginning of the next file - the third VMS header. You can also
|
|||
|
use mt to skip backwards (bsf), rewind (rewind) and rewind and unload the
|
|||
|
tape (offline, rewoffl).
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
13.3. Some details
|
|||
|
|
|||
|
The header and trailer files contain uppercase ASCII data used by VMS to
|
|||
|
store file information such as block size. They also contain the file name,
|
|||
|
which can be handy if you want to build scripts that automate read files or
|
|||
|
search for a particular file. The first header on a tape volume is slightly
|
|||
|
different than subsequent headers.
|
|||
|
|
|||
|
For a file that is the first file on the tape, as in header1 of the above
|
|||
|
example, the first four characters will be "VOL1" followed by the volume
|
|||
|
name. In the example, header1 starts with "VOL1C66A2". This is followed by a
|
|||
|
series of spaces terminated with a numeral. After that is the string "HDR1"
|
|||
|
which indicates that this is a file header. The characters immediately
|
|||
|
following the HDR1 string are the VMS file name. In in the example, this is
|
|||
|
"HDR1CE66-2.EVT". The next field is the volume name again.
|
|||
|
|
|||
|
For files that are not the first file on the tape, the initial VOL1 field is
|
|||
|
not present. Other than that the header has the same structure as for the
|
|||
|
initial file. Another useful field is the 7th field, which will end with
|
|||
|
"DECFILES11A". This must be present on tapes that conform to the DEC Files11A
|
|||
|
standard.
|
|||
|
|
|||
|
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
| field initial header subsequent headers |
|
|||
|
| ===== ============= ================== |
|
|||
|
| 1 VOL1 + volume name HDR1 + file name |
|
|||
|
| 2 3HDR1 + file name volume name |
|
|||
|
| 3 volume name |
|
|||
|
| |
|
|||
|
| 6 ...DECFILES11A |
|
|||
|
| 7 ...DECFILES11A |
|
|||
|
+---------------------------------------------------------------------------+
|
|||
|
|
|||
|
|
|||
|
For full details on the header and trailer format, see the DEC FILES11A
|
|||
|
documentation (on the orange/grey wall - ask your local VMS folks :-).
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
13.4. Comment on Block Size
|
|||
|
|
|||
|
In the example, I used a block size of 16k. On a *nix system, there is no
|
|||
|
block size associated with a file on disk while, under VMS, each file has a
|
|||
|
specific block size. That means that block size doesn't matter too much on
|
|||
|
the Linux end... unless it makes it hard to read the tape. If you have
|
|||
|
difficulty figuring out the block size and reading a tape, you can try
|
|||
|
setting the hardware block size on your tape drive using `mt -f $TAPE setblk
|
|||
|
0'. The exact form of the setblk option (and its availability) may depend on
|
|||
|
the version of mt, the tape drive hardware interface and on your particular
|
|||
|
flavor of *nix.
|
|||
|
|
|||
|
(Thanks to Wojtek Skulski ([skulski@nsrlc6.nsrl.rochester.edu] ??) for
|
|||
|
pointing out setblk.)
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
14. The End
|
|||
|
|
|||
|
14.1. Copyright
|
|||
|
|
|||
|
Unless otherwise stated, Linux HOWTO documents are copyrighted by their
|
|||
|
respective authors. Linux HOWTO documents may be reproduced and distributed
|
|||
|
in whole or in part, in any medium physical or electronic, as long as this
|
|||
|
copyright notice is retained on all copies. Commercial redistribution is
|
|||
|
allowed and encouraged; however, the author would like to be notified of any
|
|||
|
such distributions.
|
|||
|
|
|||
|
All translations, derivative works, or aggregate works incorporating any
|
|||
|
Linux HOWTO documents must be covered under this copyright notice. That is,
|
|||
|
you may not produce a derivative work from a HOWTO and impose additional
|
|||
|
restrictions on its distribution. Exceptions to these rules may be granted
|
|||
|
under certain conditions; please contact the Linux HOWTO coordinator at the
|
|||
|
address given below.
|
|||
|
|
|||
|
In short, we wish to promote dissemination of this information through as
|
|||
|
many channels as possible. However, we do wish to retain copyright on the
|
|||
|
HOWTO documents, and would like to be notified of any plans to redistribute
|
|||
|
the HOWTOs.
|
|||
|
|
|||
|
If you have questions, please contact Tim Bynum, the Linux HOWTO coordinator,
|
|||
|
at [linux-howto@sunsite.unc.edu] ?? via email.
|
|||
|
-----------------------------------------------------------------------------
|
|||
|
|
|||
|
14.2. Disclaimer
|
|||
|
|
|||
|
This work was written following the experience we had at the Settore di
|
|||
|
Geofisica of the Universita' di Bologna (Italy), where a VAX 4000 has been
|
|||
|
superseded and replaced by Linux-based Pentium PCs. Most of my colleagues are
|
|||
|
VMS users, and some of them have switched to Linux.
|
|||
|
|
|||
|
``From VMS to Linux HOWTO'' was written by Guido Gonzato, [guido ``at''
|
|||
|
ibogeo.df.unibo.it] ??, and Mike Miller, [miller5@uiuc.edu] ?? who
|
|||
|
contributed the section on reading VMS tapes. Many thanks to my colleagues
|
|||
|
and friends who helped me define the needs and habits of the average VMS
|
|||
|
user, especially to Dr. Warner Marzocchi.
|
|||
|
|
|||
|
Please help me improve this HOWTO. I'm not a VMS expert and never will be, so
|
|||
|
your suggestions and bug reports are more than welcome.
|
|||
|
|
|||
|
Enjoy,
|
|||
|
|
|||
|
Guido =8-)
|