Unix Administration

402  Download (0)

Full text


UNIX Administration Course

Day 1:

Part 1: Introduction to the course. Introduction to UNIX. History of UNIX and key features. Comparison with other OSs. Part 2: The basics: files, UNIX shells, editors, commands. Regular Expressions and Metacharacters in Shells. Part 3: File ownership and access permissions.

Online help (man pages, etc.)

Day 2:

Part 1: System identity (system name, IP address, etc.)

Software: vendor, commercial, shareware, freeware (eg. GNU). Hardware features: auto-detection, etc.

UNIX Characteristics: integration, stability, reliability, security, scalability, performance. Part 2: Shell scripts.

Part 3: System monitoring tools and tasks.

Part 4: Further shell scripts. Application development tools: compilers, debuggers, GUI toolkits, high-level APIs.

Day 3:

Part 1: Installing an OS and software: inst, swmgr. OS updates, patches, management issues.

Part 2: Organising a network with a server. NFS. Quotas. Installing/removing internal/external hardware.

SGI OS/software/hardware installation. Network setup. Part 3: Daily system administration tasks, eg. data backup. System bootup and shutdown, events, daemons.

Part 4: Security/Access control: the law, firewalls, ftp. Internet access: relevant files and services. Course summary.

Part 5: Exploring administration issues, security, hacking, responsibility, end-user support, the law (discussion). Indy/Indy attack/defense using IRIX 5.3 vs. IRIX 6.5 (two groups of 3 or 4 each).


Day 1:

Part 1: Introduction to the course. Introduction to UNIX. History Of UNIX and key features. Comparison with other OSs.

Introduction to UNIX and the Course.

The UNIX operating system (OS) is widely used around the world, eg.

 The backbone of the Internet relies on UNIX-based systems and services, as do the systems used by most Internet Service Providers (ISPs).

 Major aspects of everyday life are managed using UNIX-based systems, eg. banks, booking systems, company databases, medical records, etc.

 Other 'behind the scenes' uses concern data-intensive tasks, eg. art, design, industrial design, CAD and computer animation to real-time 3D graphics, virtual reality, visual simulation & training, data visualisation, database management, transaction processing, scientific research, military applications, computational challenges, medical modeling, entertainment and games, film/video special effects, live on-air broadcast effects, space exploration, etc.

As an OS, UNIX is not often talked about in the media, perhaps because there is no single large company such as Microsoft to which one can point at and say, "There's the company in charge of UNIX." Most public talk is of Microsoft, Bill gates, Intel, PCs and other more visible aspects of the computing arena, partly because of the home-based presence of PCs and the rise of the Internet in the public eye. This is ironic because OSs like MS-DOS, Win3.1, Win95 and WinNT all draw many of their basic features from UNIX, though they lack UNIX's sophistication and power, mainly because they lack so many key features and a lengthy development history. In reality, a great deal of the everyday computing world relies on UNIX-based systems running on computers from a wide variety of vendors such as Compaq (Digital Equipment Corporation, or DEC), Hewlett Packard (HP), International Business Machines (IBM), Intel, SGI (was Silicon Graphics Inc., now just 'SGI'), Siemens Nixdorf, Sun Microsystems (Sun), etc.

In recent years, many companies which previously relied on DOS or Windows have begun to realise that UNIX is increasingly important to their business, mainly because of what UNIX has to offer and why, eg. portability, security, reliability, etc. As demands for handling data grow, and companies embrace new methods of manipulating data (eg. data mining and visualisation), the need for systems that can handle these problems forces companies to look at solutions that are beyond the Wintel platform in performance, scalability and power.

Oil companies such as Texaco [1] and Chevron [2] are typical organisations which already use UNIX systems extensively because of their data-intensive tasks and a need for extreme reliability and scalability. As costs have come down, along with changes in the types of available UNIX system (newer low-end designs, eg. Ultra5, O2, etc.), small and medium-sized companies are


looking towards UNIX solutions to solve their problems. Even individuals now find that older 2nd-hand UNIX systems have significant advantages over modern Wintel solutions, and many companies/organisations have adopted this approach too [3].

This course serves as an introduction to UNIX, its history, features, operation, use and services, applications, typical administration tasks, and relevant related topics such as the Internet,

security and the Law. SGI's version of UNIX, called IRIX, is used as an example UNIX OS. The network of SGI Indys and an SGI Challenge S server I admin is used as an example UNIX hardware platform.


The course lasts three days, each day consisting of a one hour lecture followed by a two hour practical session in the morning, and then a three hour practical session in the afternoon; the only exceptions to this are Day 1 which begins with a two hour lecture, and Day 3 which has a 1 hour afternoon lecture.

Detailed notes are provided for all areas covered in the lectures and the practical sessions. With new topics introduced step-by-step, the practical sessions enable first-hand familiarity with the topics covered in the lectures.

As one might expect of an OS which has a vast range of features, capabilities and uses, it is not possible to cover everything about UNIX in three days, especially the more advanced topics such as kernel tuning which most administrators rarely have to deal with. Today, modern UNIX hardware and software designs allow even very large systems with, for example, 64 processors to be fully setup at the OS level in little more than an hour [4]. Hence, the course is based on the author's experience of what a typical UNIX user and administrator (admin) has to deal with, rather than attempting to present a highly compressed 'Grand Description of Everything' which simply isn't necessary to enable an admin to perform real-world system administration on a daily basis.

For example, the precise nature and function of the Sendmail email system on any flavour of UNIX is not immediately easy to understand; looking at the various files and how Sendmail works can be confusing. However, in the author's experience, due to the way UNIX is designed, even a default OS installation without any further modification is sufficient to provide users with a fully functional email service [5], a fact which shouldn't be of any great surprise since email is a built-in aspect of any UNIX OS. Thus, the presence of email as a fundamental feature of UNIX is explained, but configuring and customising Sendmail is not.

History of UNIX


BTL = Bell Telephone Laboratories GE = General Electric

WE = Western Electric

MIT = Massachusetts Institute of Technology BSD = Berkeley Standard Domain

Summary History:

1957: BTL creates the BESYS OS for internal use.

1964: BTL needs a new OS, develops Multics with GE and MIT.

1969: UNICS project started at BTL and MIT; OS written using the B language.

1970: UNICS project well under way; anonymously renamed to UNIX. 1971: UNIX book published. 60 commands listed.

1972: C language completed (a rewritten form of B). Pipe concept invented. 1973: UNIX used on 16 sites. Kernel rewritten in C. UNIX spreads rapidly. 1974: Work spreads to Berkeley. BSD UNIX is born.

1975: UNIX licensed to universities for free.

1978: Two UNIX styles, though similar and related: System V and BSD. 1980s: Many companies launch their versions of UNIX, including Microsoft.


A push towards cross-platform standards: POSIX/X11/Motif Independent organisations with cross-vendor membership Control future development and standards. IEEE included. 1990s: 64bit versions of UNIX released. Massively scalable systems. Internet springs to life, based on UNIX technologies. Further Standardisation efforts (OpenGL, UNIX95, UNIX98).

Detailed History.

UNIX is now nearly 40 years old. It began life in 1969 as a combined project run by BTL, GE and MIT, initially created and managed by Ken Thompson and Dennis Ritchie [6]. The goal was to develop an operating system for a large computer which could support hundreds of simultaneous users. The very early phase actually started at BTL in 1957 when work began on what was to become BESYS, an OS developed by BTL for their internal needs.

In 1964, BTL started on the third generation of their computing resources. They needed a

new operating system and so initiated the MULTICS (MULTIplexed operating and Computing System) project in late 1964, a combined research programme between BTL, GE and MIT. Due to differing design goals between the three groups, Bell pulled out of the project in 1969, leaving personnel in Bell's Computing Science and Research Center with no usable computing


As a response to this move, Ken Thompson and Dennis Ritchie offered to design a new OS for BTL, using a PDP-7 computer which was available at the time. Early work was done in a language designed for writing compilers and systems programming, called BCPL (Basic Combined Programming Language). BCPL was quickly simplified and revised to produce a better language called B.

By the end of 1969 an early version of the OS was completed; a pun at previous work on

Multics, it was named UNICS (UNIplexed operating and Computing System) - an "emasculated Multics". UNICS included a primitive kernel, an editor, assembler, a simple shell command interpreter and basic command utilities such as rm, cat and cp. In 1970, extra funding arose from BTL's internal use of UNICS for patent processing; as a result, the researchers obtained a DEC PDP-11/20 for further work (24K RAM). At that time, the OS used 12K, with the remaining 12K used for user programs and a RAM disk (file size limit was 64K, disk size limit was 512K). BTL's Patent Department then took over the project, providing funding for a newer machine, namely a PDP-11/45. By this time, UNICS had been abbreviated to UNIX - nobody knows whose idea it was to change the name (probably just phonetic convenience).


In 1971, a book on UNIX by Thompson and Ritchie described over 60 commands, including:

 b (compile a B program) 

 chdir (change working directory) 

 chmod (change file access permissions) 

 chown (change file ownership) 

 cp (copy a file) 

 ls (list directory contents) 

 who (show who is on the system) 

Even at this stage, fundamentally important aspects of UNIX were already firmly in place as core features of the overall OS, eg. file ownership and file access permissions. Today, other operating systems such as WindowsNT do not have these features as a rigorously integrated aspect of the core OS design, resulting in a plethora of overhead issues concerning security, file management, user access control and administration. These features, which are very important to modern computing environments, are either added as convoluted bolt-ons to other OSs or are totally non-existent (NT does have a concept of file ownership, but it isn't implemented very well;

regrettably, much of the advice given by people from VMS to Microsoft on how to implement such features was ignored).

In 1972, Ritchie and Thompson rewrote B to create a new language called C. Around this time, Thompson invented the 'pipe' - a standard mechanism for allowing the output of one program or process to be used as the input for another. This became the foundation of the future UNIX OS development philosophy: write programs which do one thing and do it well; write programs which can work together and cooperate using pipes; write programs which support text streams because text is a 'universal interface' [6].

By 1973, UNIX had spread to sixteen sites, all within AT&T and WE. First made public at a conference in October that year, within six months the number of sites using UNIX had tripled. Following a publication of a version of UNIX in 'Communications of the ACM' in July 1974, requests for the OS began to rapidly escalate. Crucially at this time, the fundamentals of C were complete and much of UNIX's 11000 lines of code were rewritten in C - this was a major breakthrough in operating systems design: it meant that the OS could be used on virtually any computer platform since C was hardware independent.

In late 1974, Thompson went to University of California at Berkeley to teach for a year. Working with Bill Joy and Chuck Haley, the three developed the 'Berkeley' version of UNIX (named BSD, for Berkeley Software Distribution), the source code of which was widely distributed to


students on campus and beyond, ie. students at Berkeley and elsewhere also worked on

improving the OS. BTL incorporated useful improvements as they arose, including some work from a user in the UK. By this time, the use and distribution of UNIX was out of BTL's control, largely because of the work at Berkeley on BSD.

Developments to BSD UNIX added the vi editor, C-based shell interpreter, the Sendmail email system, virtual memory, and support for TCP/IP networking technologies (Transmission Control Protocol/Internet Protocol). Again, a service as important as email was now a fundamental part of the OS, eg. the OS uses email as a means of notifying the system administrator of system status, problems, reports, etc. Any installation of UNIX for any platform automatically includes email; by complete contrast, email is not a part of Windows3.1, Win95, Win98 or WinNT - email for these OSs must be added separately (eg. Pegasus Mail), sometimes causing problems which would not otherwise be present.

In 1975, a further revision of UNIX known as the Fifth Edition was released and licensed to universities for free. After the release of the Seventh Edition in 1978, the divergence of UNIX development along two separate but related paths became clear: System V (BTL) and BSD (Berkeley). BTL and Sun combined to create System V Release 4 (SVR4) which brought together System V with large parts of BSD. For a while, SVR4 was the more rigidly controlled, commercial and properly supported (compared to BSD on its own), though important work occurred in both versions and both continued to be alike in many ways. Fearing Sun's possible domination, many other vendors formed the Open Software Foundation (OSF) to further work on BSD and other variants. Note that in 1979, a typical UNIX kernel was still only 40K.

Because of a legal decree which prevented AT&T from selling the work of BTL, AT&T allowed UNIX to be widely distributed via licensing schemas at minimal or zero cost. The first genuine UNIX vendor, Interactive Systems Corporation, started selling UNIX systems for automating office work. Meanwhile, the work at AT&T (various internal design groups) was combined, then taken over by WE, which became UNIX System Laboratories (now owned by Novell). Later releases included Sytem III and various releases of System V. Today, most popular brands of UNIX are based either on SVR4, BSD, or a combination of both (usually SVR4 with standard enhancements from BSD, which for example describes SGI's IRIX version perfectly). As an aside, there never was a System I since WE feared companies would assume a 'system 1' would be bug-ridden and so would wait for a later release (or purchase BSD instead!).

It's worth noting the influence from the superb research effort at Xerox Parc, which was working on networking technologies, electronic mail systems and graphical user interfaces, including the proverbial 'mouse'. The Apple Mac arose directly from the efforts of Xerox Parc which,

incredibly and much against the wishes of many Xerox Parc employees, gave free

demonstrations to people such as Steve Jobs (founder of Apple) and sold their ideas for next to nothing ($50000). This was perhaps the biggest financial give-away in history [7].

One reason why so many different names for UNIX emerged over the years was the practice of AT&T to license the UNIX software, but not the UNIX name itself. The various flavours of UNIX may have different names (SunOS, Solaris, Ultrix, AIX, Xenix, UnixWare, IRIX, Digital UNIX, HP-UX, OpenBSD, FreeBSD, Linux, etc.) but in general the differences between them


are minimal. Someone who learns a particular vendor's version of UNIX (eg. Sun's Solaris) will easily be able to adapt to a different version from another vendor (eg. DEC's Digital UNIX). Most differences merely concern the names and/or locations of particular files, as opposed to any core underlying aspect of the OS.

Further enhancements to UNIX included compilation management systems such as make and Imake (allowing for a single source code release to be compiled on any UNIX platform) and support for source code management (SCCS). Services such as telnet for remote communication were also completed, along with ftp for file transfer, and other useful functions.

In the early 1980s, Microsoft developed and released its version of UNIX called Xenix (it's a shame this wasn't pushed into the business market instead of DOS). The first 32bit version of UNIX was released at this time. SCO developed UnixWare which is often used today by Intel for publishing performance ratings for its x86-based processors [8]. SGI started IRIX in the early 1980s, combining SVR4 with an advanced GUI. Sun's SunOS sprang to life in 1984, which became widely used in educational institutions. NeXT-Step arrived in 1989 and was hailed as a superb development platform; this was the platform used to develop the game 'Doom', which was then ported to DOS for final release. 'Doom' became one of the most successful and influential PC games of all time and was largely responsible for the rapid demand for better hardware graphics systems amongst home users in the early 1990s - not many people know that it was originally designed on a UNIX system though. Similarly, much of the development work for Quake was done using a 4-processor Digital Alpha system [9].

During the 1980s, developments in standardised graphical user interface elements were introduced (X11 and Motif) along with other major additional features, especially Sun's Networked File System (NFS) which allows multiple file systems, from multiple UNIX

machines from different vendors, to be transparently shared and treated as a single file structure. Users see a single coherant file system even though the reality may involve many different systems in different physical locations.

By this stage, UNIX's key features had firmly established its place in the computing world, eg. Multi-tasking and multi-user (many independent processes can run at once; many users can use a single system at the same time; a single user can use many systems at the same time). However, in general, the user interface to most UNIX variants was poor: mainly text based. Most vendors began serious GUI development in the early 1980s, especially SGI which has traditionally focused on visual-related markets [10].

From the point of view of a mature operating system, and certainly in the interests of companies and users, there were significant moves in the 1980s and early 1990s to introduce standards which would greatly simplify the cross-platform use of UNIX. These changes, which continue today, include:

 The POSIX standard [6], begun in 1985 and released in 1990: a suite of application programming interface standards which provide for the portability of application source code relating to operating system services, managed by the X/Open group.


 UNIX95, UNIX98: a set of standards and guidelines to help make the various UNIX flavours more coherant and cross-platform.

 OpenGL: a 3D graphics programming standard originally developed by SGI as GL (Graphics Library), then IrisGL, eventually released as an open standard by SGI as OpenGL and rapidly adopted by all other vendors.

 Journaled file systems such as SGI's XFS which allow the creation, management and use of very large file systems, eg. multiple terabytes in size, with file sizes from a single byte to millions of terabytes, plus support for real-time and predictable response. EDIT (2008): Linux can now use XFS.

 Interoperability standards so that UNIX systems can seamlessly operate with non-UNIX systems such as DOS PCs, WindowsNT, etc.

Standards Notes POSIX:

X/Open eventually became UNIX International (UI), which competed for a while with OSF. The US Federal Government initiated POSIX (essentially a version of UNIX), requiring all government contracts to conform to the POSIX standard - this freed the US government from being tied to vendor-specific systems, but also gave UNIX a major boost in popularity as users benefited from the industry's rapid adoption of accepted standards.

X11 and Motif:

Programming directly using low-level X11/Motif libraries can be non-trivial. As a result, higher level programming interfaces were developed in later years, eg. the ViewKit library suite for SGI systems. Just as 'Open Inventor' is a higher-level 3D graphics API to OpenGL, ViewKit allows one to focus on developing the application and solving the client's problem, rather than having to wade through numerous low-level details. Even higher-level GUI-based toolkits exist for rapid application development, eg. SGI's RapidApp.


Most modern UNIX variants comply with these standards, though Linux is a typical exception (it is POSIX-compliant, but does not adhere to other standards). There are several UNIX variants available for PCs, excluding Alpha-based systems which can also use NT (MIPS CPUs could once be used with NT as well, but Microsoft dropped NT support for MIPS due to competition fears from Intel whose CPUs were not as fast at the time [11]):

 Linux Open-architecture, free, global development, insecure.


 OpenBSD More rigidly controlled, much more secure. 

 FreeBSD Somewhere inbetween the above two. 

 UnixWare More advanced. Scalable. Not free. 

There are also commercial versions of Linux which have additional features and services, eg. Red Hat Linux and Calderra Linux. Note that many vendors today are working to enable the various UNIX variants to be used with Intel's CPUs - this is needed by Intel in order to decrease its dependence on the various Microsoft OS products.


Apple was the last company to adopt OpenGL. In the 1990s, Microsoft attempted to force its own standards into the marketplace (Direct3D and DirectX) but this move was

doomed to failure due to the superior design of OpenGL and its ease of use, eg. games designers such as John Carmack (Doom, Quake, etc.) decided OpenGL was the much better choice for games development. Compared to Direct3D/DirectX, OpenGL is far superior for seriously complex problems such as visual simulation, military/industrial applications, image processing, GIS, numerical simulation and medical imaging.

In a move to unify the marketplace, SGI and Microsoft signed a deal in the late 1990s to merge DirectX and Direct3D into OpenGL - the project, called Fahrenheit, will

eventually lead to a single unified graphics programming interface for all platforms from all vendors, from the lowest PC to the fastest SGI/Cray supercomputer available with thousands of processors. To a large degree, Direct3D will simply either be phased out in favour of OpenGL's methods, or focused entirely on consumer-level applications, though OpenGL will dominate in the final product for the entertainment market.

OpenGL is managed by the OpenGL Architecture Review Board, an independent organisation with member representatives from all major UNIX vendors, relevant companies and institutions.

Journaled file systems:

File systems like SGI's XFS running on powerful UNIX systems like CrayOrigin2000 can easily support sustained data transfer rates of hundreds of gigabytes per second. XFS has a maximum file size limit of 9 million terabytes.


The end result of the last 30 years of UNIX development is what is known as an 'Open System', ie. a system which permits reliable application portability, interoperability between different systems and effective user portability between a wide variety of different vendor hardware and software platforms. Combined with a modern set of compliance standards, UNIX is now a mature, well-understood, highly developed, powerful and very sophisticated OS.

Many important features of UNIX do not exist in other OSs such as WindowsNT and will not do so for years to come, if ever. These include guaranteeable reliability, security, stability, extreme scalability (thousands of processors), proper support for advanced multi-processing with unified shared memory and resources (ie. parallel compute systems with more than 1 CPU), support for genuine real-time response, portability and an ever-increasing ease-of-use through highly

advanced GUIs. Modern UNIX GUIs combine the familiar use of icons with the immense power and flexibility of the UNIX shell command line which, for example, supports full remote

administration (a significant criticism of WinNT is the lack of any real command line interface for remote administration). By contrast, Windows2000 includes a colossal amount of new code which will introduce a plethora of new bugs and problems.

A summary of key UNIX features would be:

 Multi-tasking: many different processes can operate independently at once.

 Multi-user: many users can use a single machine at the same time; a single user can use multiple machines at the same time.

 Multi-processing: most commercial UNIX systems scale to at least 32 or 64 CPUs (Sun, IBM, HP), while others scale to hundreds or thousands (IRIX, Unicos, AIX, etc.; Blue Mountain [12], Blue Pacific, ASCI Red). Today, WindowsNT cannot reliably scale to even 8 CPUs. Intel will not begin selling 8-way chip sets until Q3 1999.

 Multi-threading: automatic parallel execution of applications across multiple CPUs and graphics systems when programs are written using the relevant extensions and libraries. Some tasks are naturally non-threadable, eg. Rendering animation frames for movies (each processor computes a single frame using a round-robin approach), while others lend themselves very well to parallel execution, eg. Computational Fluid Dynamics, Finite Element Analysis, Image Processing, Quantum Chronodynamics, weather

modeling, database processing, medical imaging, visual simulation and other areas of 3D graphics, etc.

 Platform independence and portability: applications written on UNIX systems will compile and run on other UNIX systems if they're developed with a standards-based approach, eg. the use of ANSI C or C++, Motif libraries, etc.; UNIX hides the hardware architecture from the user, easing portability. The close relationship between UNIX and C, plus the fact that the UNIX shell is based on C, provides for a powerful development environment. Today, GUI-based development environments for UNIX systems also exist, giving even greater power and flexibility, eg. SGI's WorkShop Pro CASE tools and RapidApp.

 Full 64bit environment: proper support for very large memory spaces, up to hundreds of GB of RAM, visible to the system as a single combined memory space. Comparison: NT's current maximum limit is 4GB; IRIX's current commercial limit is 512GB, though


Blue Mountain's 6144-CPU SGI system has a current limit of 12000GB RAM (twice that if the CPUs were upgraded to the latest model). Blue Mountain has 1500GB RAM installed at the moment.

 Inter-system communication: services such as telnet, Sendmail, TCP/IP, remote login (rlogin), DNS, NIS, NFS, etc. Sophisticated security and access control. Features such as email and telnet are a fundamental part of UNIX, but they must be added as extras to other OSs. UNIX allows one to transparently access devices on a remote system and even install the OS using a CDROM, DAT or disk that resides on a remote machine. Note that some of the development which went into these technologies was in conjunction with the evolution of ArpaNet (the early Internet that was just for key US government, military, research and educational sites).

 File identity and access: unique file ownership and a logical file access permission structure provide very high-level management of file access for use by users and administrators alike. OSs which lack these features as a core part of the OS make it far too easy for a hacker or even an ordinary user to gain administrator-level access (NT is a typical example).

 System identity: every UNIX system has a distinct unique entity, ie. a system name and an IP (Internet Protocol) address. These offer numerous advantages for users and administrators, eg. security, access control, system-specific environments, the ability to login and use multiple systems at once, etc.

 Genuine 'plug & play': UNIX OSs already include drivers and support for all devices that the source vendor is aware of. Adding most brands of disks, printers, CDROMs, DATs, Floptical drives, ZIP or JAZ drives, etc. to a system requires no installation of any drivers at all (the downside of this is that a typical modern UNIX OS installation can be large, eg. 300MB). Detection and name-allocation to devices is largely automatic - there is no need to assign specific interrupt or memory addresses for devices, or assign labels for disk drives, ZIP drives, etc. Devices can be added and removed without affecting the long-term operation of the system. This also often applies to internal components such as CPUs, video boards, etc. (at least for SGIs).

UNIX Today.

In recent years, one aspect of UNIX that was holding it back from spreading more widely was cost. Many vendors often charged too high a price for their particular flavour of UNIX. This made its use by small businesses and home users prohibitive. The ever decreasing cost of PCs, combined with the sheer marketing power of Microsoft, gave rise of the rapid growth of Windows and now WindowsNT. However, in 1993, Linus Torvalds developed a version of UNIX called Linux (he pronounces it rather like 'leenoox', rhyming with 'see-books') which was free and ran on PCs as well as other hardware platforms such as DEC machines. In what must be one of the most astonishing developments of the computer age, Linux has rapidly grown to become a highly popular OS for home and small business use and is now being supported by many major companies too, including Oracle, IBM, SGI, HP, Dell and others.


Linux does not have the sophistication of the more traditional UNIX variants such as SGI's IRIX, but Linux is free (older releases of IRIX such as IRIX 6.2 are also free, but not the very latest release, namely IRIX 6.5). This has resulted in the rapid adoption of Linux by many people and businesses, especially for servers, application development, home use, etc. With the recent announcement of support for multi-processing in Linux for up to 8 CPUs, Linux is becoming an important player in the UNIX world and a likely candidate to take on Microsoft in the battle for OS dominance.

However, it'll be a while before Linux will be used for 'serious' applications since it does not have the rigorous development history and discipline of other UNIX versions, eg. Blue Mountain is an IRIX system consisting of 6144 CPUs, 1500GB RAM, 76000GB disk space, and capable of 3000 billion floating-point operations per second. This level of system development is what drives many aspects of today's UNIX evolution and the hardware which supports UNIX OSs. Linux lacks this top-down approach and needs a lot of work in areas such as security and support for graphics, but Linux is nevertheless becoming very useful in fields such as render-farm construction

for movie studios, eg. a network of cheap PentiumIII machines, networked and running the free Linux OS, reliable and stable. The film "Titanic" was the first major film which used a Linux-based render-farm, though it employed many other UNIX systems too (eg. SGIs, Alphas), as well as some NT systems.

EDIT (2008): Linux is now very much used for serious work, running most of the planet's Internet servers, and widely used in movie studios for Flame/Smoke on professional x86 systems. It's come a long way since 1999, with new distributions such as Ubuntu and Gentoo proving very popular. At the high-end, SGI offers products that range from its shared-memory Linux-based Altix 4700 system with up to 1024 CPUs, to the Altix ICE, a highly expandable XEON/Linux cluster system with some sites using machines with tens of thousands of cores. UNIX has come a long way since 1969. Thompson and Ritchie could never have imagined that it would spread so widely and eventually lead to its use in such things as the control of the Mars Pathfinder probe which last year landed on Mars, including the operation of the Internet web server which allowed millions of people around the world to see the images brought back as the Martian event unfolded [13].

Today, from an administrator's perspective, UNIX is a stable and reliable OS which pretty much runs itself once it's properly setup. UNIX requires far less daily administration than other OSs


such as NT - a factor not often taken into account when companies form purchasing decisions (salaries are a major part of a company's expenditure). UNIX certainly has its baggage in terms of file structure and the way some aspects of the OS actually work, but after so many years most if not all of the key problems have been solved, giving rise to an OS which offers far superior reliability, stability, security, etc. In that sense, UNIX has very well-known baggage which is absolutely vital to safety-critical applications such as military, medical, government and industrial use. Byte magazine once said that NT was only now tackling OS issues which other OSs had solved years before [14].

Thanks to a standards-based and top-down approach, UNIX is evolving to remove its baggage in a reliable way, eg. the introduction of the NSD (Name Service Daemon) to replace DNS

(Domain Name Service), NIS (Network Information Service) and aspects of NFS operation; the new service is faster, more efficient, and easier on system resources such as memory and network usage.

However, in the never-ending public relations battle for computer systems and OS dominance, NT has firmly established itself as an OS which will be increasingly used by many companies due to the widespread use of the traditional PC and the very low cost of Intel's mass-produced CPUs. Rival vendors continue to offer much faster systems than PCs, whether or not UNIX is used, so I expect to see interesting times ahead in the realm of OS development. Companies like SGI bridge the gap by releasing advanced hardware systems which support NT (eg. the Visual Workstation 320 [15]), systems whose design is born out of UNIX-based experience.

One thing is certain: some flavour of UNIX will always be at the forefront of future OS development, whatever variant it may be.


1. Texaco processes GIS data in order to analyse suitable sites for oil exploration. Their models can take several months to run even on large multi-processor machines. However, as systems become faster, companies like Texaco simply try to solve more complex problems, with more detail, etc.

2. Chevron's Nigerian office has, what was in mid-1998, the fastest supercomputer in Africa, namely a 16-processor SGI POWER Challenge (probably replaced by now with a modern 64-CPU Origin2000). A typical data set processed by the system is about 60GB which takes around two weeks to process, during which time the system must not go wrong or much processing time is lost. For individual work, Chevron uses Octane workstations which are able to process 750MB of volumetric GIS data in less than three seconds. Solving these types of problems with PCs is not yet possible.

3. The 'Tasmania Parks and Wildlife Services' (TPWS) organisation is responsible for the management and environmental planning of Tasmania's National Parks. They use modern systems like the SGI O2 and SGI Octane for modeling and simulation (virtual park models to aid in decision making and planning), but have found that much older systems such as POWER Series Predator and Crimson RealityEngine (SGI systems dating from


1992) are perfectly adequate for their tasks, and can still outperform modern PCs. For example, the full-featured pixel-fill rate of their RealityEngine system (320M/sec), which supports 48bit colour at very high resolutions (1280x2048 with 160MB VRAM), has still not been bettered by any modern PC solution. Real-time graphics comparisons at

http://www.blender.nl/stuff/blench1.html show Crimson RE easily outperforming many modern PCs which ought to be faster given RE is 7 years old. Information supplied by Simon Pigot (TPWS SysAdmin).

4. "State University of New York at Buffalo Teams up with SGI for Next-Level

Supercomputing Site. New Facility Brings Exciting Science and Competitive Edge to University":


5. Even though the email-related aspects of the Computing Department's SGI network have not been changed in any way from the default settings (created during the original OS installation), users can still email other users on the system as well as send email to external sites.

6. Unix history:


A Brief History of UNIX:


UNIX Lectures:


Basic UNIX:


POSIX: Portable Operating System Interface:


7. "The Triumph of the Nerds", Channel 4 documentary. 8. Standard Performance Evaluation Corporation:


Example use of UnixWare by Intel for benchmark reporting:

http://www.specbench.org/osg/cpu95/results/res98q3/cpu95-980831-03026.html http://www.specbench.org/osg/cpu95/results/res98q3/cpu95-980831-03023.html 9. "My Visit to the USA" (id Software, Paradigm Simulation Inc., NOA):


10. Personal IRIS 4D/25, PCW Magazine, September 1990, pp. 186:


IndigoMagic User Environment, SGI, 1993 [IND-MAGIC-BRO(6/93)]. IRIS Indigo Brochure, SGI, 1991 [HLW-BRO-01 (6/91)].

"Smooth Operator", CGI Magazine, Vol4, Issue 1, Jan/Feb 1999, pp. 41-42.

Digital Media World '98 (Film Effects and Animation Festival, Wembley Conference Center, London). Forty six pieces of work were submitted to the conference magazine by company attendees. Out of the 46 items, 43 had used SGIs; of these, 34 had used only SGIs.


11. "MIPS-based PCs fastest for WindowsNT", "MIPS Technologies announces 200MHz R4400 RISC microprocessor", "MIPS demonstrates Pentium-class RISC PC designs", - all from IRIS UK, Issue 1, 1994, pp. 5.

12. Blue Mountain, Los Alamos National Laboratory:

13. http://www.lanl.gov/asci/

14. http://www.lanl.gov/asci/bluemtn/ASCI_fly.pdf 15. http://www.lanl.gov/asci/bluemtn/bluemtn.html 16. http://www.lanl.gov/asci/bluemtn/t_sysnews.shtml


17. "Silicon Graphics Technology Plays Mission-Critical Role in Mars Landing" http://www.sgi.com/newsroom/press_releases/1997/june/jplmars_release.html "Silicon Graphics WebFORCE Internet Servers Power Mars Web Site, One of the World's Largest Web Events"

http://www.sgi.com/newsroom/press_releases/1997/july/marswebforce_release.html "PC Users Worldwide Can Explore VRML Simulation of Mars Terrain Via the Internet" http://www.sgi.com/newsroom/press_releases/1997/june/vrmlmars_release.html

18. "Deja Vu All Over Again"; "Windows NT security is under fire. It's not just that there are holes, but that they are holes that other OSes patched years ago", Byte Magazine, Vol 22 No. 11, November 1997 Issue, pp. 81 to 82, by Peter Mudge and Yobie Benjamin. 19. VisualWorkstation320 Home Page:


Day 1:

Part 2: The basics: files, UNIX shells, editors, commands. Regular Expressions and Metacharacters in Shells.

UNIX Fundamentals: Files and the File System.

At the lowest level, from a command-line point of view, just about everything in a UNIX

environment is treated as a file - even hardware entities, eg. Printers, disks and DAT drives. Such items might be described as 'devices' or with other terms, but at the lowest level they are visible to the admin and user as files somewhere in the UNIX file system (under /dev in the case of hardware devices). Though this structure may seem a little odd at first, it means that system commands can use a common processing and communication interface no matter what type of file they're dealing with, eg. Text, pipes, data redirection, etc. (these concepts are explained in more detail later).

The UNIX file system can be regarded as a top-down tree of files and directories, starting with the top-most 'root' directory. A directory can be visualised as a filing cabinet, other directories as folders within the cabinet and individual files as the pieces of paper within folders. It's a useful analogy if one isn't familiar with file system concepts, but somewhat inaccurate since a directory in a computer file system can contain files on their own as well as other directories, ie. Most office filing cabinets don't have loose pieces of paper outside of folders.

UNIX file systems can also have 'hidden' files and directories. In DOS, a hidden file is just a file with a special attribute set so that 'dir' and other commands do not show the file; by contrast, a hidden file in UNIX is any file which begins with a dot '.' (period) character, ie. the hidden status is a result of an aspect of the file's name, not an attribute that is bolted onto the file's general existence. Further, whether or not a user can access a hidden file or look inside a hidden

directory has nothing to do with the fact that the file or directory is hidden from normal view (a hidden file in DOS cannot be written to). Access permissions are a separate aspect of the fundamental nature of a UNIX file and are dealt with later.

The 'ls' command lists files and directories in the current directory, or some other part of the file system by specifying a 'path' name. For example:

ls /

Will show the contents of the root directory, which may typically contain the following:

CDROM dev home mapleson proc stand usr bin dumpster lib nsmail root.home tmp var debug etc lib32 opt sbin unix

Figure 1. A typical root directory shown by 'ls'.

Almost every UNIX system has its own unique root directory and file system, stored on a disk within the machine. The exception is a machine with no internal disk, running off a remote server in some way;


such systems are described as 'diskless nodes' and are very rare in modern UNIX environments, though still used if a diskless node is an appropriate solution.

Some of the items in Fig 1. Are files, while others are directories? If one uses an option '-F' with the ls command, special characters are shown after the names for extra clarity:

/ - directory

* - executable file

@ - link to another file or directory Elsewhere in the file system

Thus, using 'ls -F' gives this more useful output:

CDROM/ dev/ home/ mapleson/ proc/ stand/ usr/ Bin/ dumpster/ lib/ nsmail/ root.home tmp/ var/ Debug/ etc/ lib32/ opt/ sbin/ unix*

Figure 2. The root directory shown by 'ls -F /'.

Fig 2 shows that most of the items are in fact other directories. Only two items are ordinary files: 'unix' and 'root.home'. 'UNIX' is the main UNIX kernel file and is often several megabytes in size for today's modern UNIX systems - this is partly because the kernel must often include support for 64bit as well as older 32bit system components. 'root.home' is merely a file created when the root user accesses the WWW using Netscape, ie. an application-specific file.

Important directories in the root directory:

/bin - many as-standard system commands are here (links to /usr/bin)

/dev - device files for keyboard, disks, printers, etc.

/etc - system configuration files

/home - user accounts are here (NFS mounted)

/lib - library files used by executable programs

/sbin - user applications and other commands

/tmp - temporary directory (anyone can create files here). This directory is normally erased on bootup

/usr - Various product-specific directories, system resource directories, locations of online help (/usr/share), header files of application

development (usr/include), further system configuration files relating to low-level


hardware which are rarely touched even by an administrator (eg. /usr/cpu and /usr/gfx).

/var - X Windows files (/var/X11), system services files (eg. software licenses in /var/flexlm), various application related files (/var/netscape, /var/dmedia), system administration files and data (/var/adm, /var/spool) and a second temporary directory (/var/tmp) which is not normally erased on bootup (an administrator can alter the

behaviour of both /tmp and /var/tmp).

/mapleson - (non-standard) my home account is here, NFS- mounted from the admin Indy called Milamber.

Figure 3. Important directories in the root directory.

Comparisons with other UNIX variants such as HP-UX, SunOS and Solaris can be found in the many FAQ (Frequently Asked Questions) files available via the Internet [1].

Browsing around the UNIX file system can be enlightening but also a little overwhelming at first. However, an admin never has to be concerned with most parts of the file structure; low-level system directories such as /var/cpu are managed automatically by various system tasks and programs. Rarely, if ever, does an admin even have to look in such directories, never mind alter their contents (the latter is probably an unwise thing to do).

From the point of view of a novice admin, the most important directory is /etc. It is this directory which contains the key system configuration files and it is these files which are most often changed when an admin wishes to alter system behaviour or properties. In fact, an admin can get to grips with how a UNIX system works very quickly, simply by learning all about the following files to begin with:

/etc/sys_id - the name of the system (may include full domain)

/etc/hosts - summary of full host names (standard file, added to by the administrator)

/etc/fstab - list of file systems to mount on bootup

/etc/passwd - password file, contains user account information

/etc/group - group file, contains details of all user groups

Figure 4. Key files for the novice administrator.

Note that an admin also has a personal account, ie. an ordinary user account, which should be used for any task not related to system administration. More precisely, an admin should only be logged in as root when it is strictly necessary, mainly to avoid unintended actions, eg. accidental use of the 'rm'


A Note on the 'man' Command.

The manual pages and other online information for the files shown in Fig 4 all list references to other related files, eg. the man page for 'fstab' lists 'mount' and 'xfs' in its 'SEE ALSO' section, as well as an entry called 'filesystems' which is a general overview document about UNIX file systems of all types, including those used by CDROMs and floppy disks. Modern UNIX releases contain a large number of useful general reference pages such as 'filesystems'. Since one may not know what is available, the 'k' and 'f' options can be used with the man command to offer

suggestions, eg. 'man -f file' gives this output (the -f option shows all man page titles for entries that begin with the word 'file'):

ferror, feof, clearerr,

fileno (3S) stream status inquiries file (1) determine file type

file (3Tcl) Manipulate file names and attributes File::Compare (3) Compare files or filehandles

File::Copy (3) Copy files or filehandles

File::DosGlob (3) DOS like globbing and then some File::Path (3) create or remove a series

of directories

File::stat (3) by-name interface to Perl's built-in stat() functions

filebuf (3C++) buffer for file I/O. FileCache (3) keep more files open than the system permits

fileevent (3Tk) Execute a script when a file becomes readable or writable

FileHandle (3) supply object methods for filehandles filename_to_devname (2) determine the device name

for the device file

filename_to_drivername (2) determine the device name for the device file

fileparse (3) split a pathname into pieces files (7P) local files name service parser library

FilesystemManager (1M) view and manage filesystems filesystems: cdfs, dos,

fat, EFS, hfs, mac, iso9660, cd-rom, kfs,

nfs, XFS, rockridge (4) IRIX filesystem types filetype (5) K-AShare's filetype specification file filetype, fileopen,

filealtopen, wstype (1) determine filetype of specified file or files

routeprint, fileconvert (1) convert file to printer or to specified filetype

Figure 5. Output from 'man -f file'.

'man -k file' gives a much longer output since the '-k' option runs a search on every man page title containing the word 'file'. So a point to note: judicious use of the man command along with other online information is an effective way to learn how any UNIX system works and how to make changes to


system behaviour. All man pages for commands give examples of their use, a summary of possible options, syntax, further references, a list of any known bugs with appropriate workarounds, etc. The next most important directory is probably /var since this is where the configuration files for many system services are often housed, such as the Domain Name Service (/var/named) and Network Information Service (/var/yp). However, small networks usually do not need these services which are aimed more at larger networks. They can be useful though, for example in aiding Internet access.

Overall, a typical UNIX file system will have over several thousand files. It is possible for an admin to manage a system without ever knowing what the majority of the system's files are for. In fact, this is a preferable way of managing a system. When a problem arises, it is more

important to know where to find relevant information on how to solve the problem, rather than try to learn the solution to every possible problem in the first instance (which is impossible). I once asked an experienced SGI administrator (the first person to ever use the massive Cray T3D supercomputer at the Edinburgh Parallel Computing Centre) what the most important thing in his daily working life was. He said it was a small yellow note book in which he had written where to find information about various topics. The book was an index on where to find facts, not a collection of facts in itself.

Hidden files were described earlier. The '-a' option can be used with the ls command to show hidden files:

ls -a /


./ .sgihelprc lib/ ../ .ssh/ lib32/ .Acroread.License .varupdate mapleson/ .Sgiresources .weblink nsmail/ .cshrc .wshttymode opt/ .desktop-yoda/ .zmailrc proc/ .ebtpriv/ CDROM/ sbin/ .expertInsight bin/ stand/ .insightrc debug/ swap/ .jotrc* dev/ tmp/ .login dumpster/ unix* .netscape/ etc/ usr/ .profile floppy/ var/ .rhosts home/

Figure 6. Hidden files shown with 'ls -a /'.

For most users, important hidden files would be those which configure their basic working environment when they login:

.cshrc .login .profile


Other hidden files and directories refer to application-specific resources such as Netscape, or GUI-related resources such as the .desktop-sysname directory (where 'sysname' is the name of the host).

Although the behaviour of the ls command can be altered with the 'alias' command so that it shows hidden files by default, the raw behaviour of ls can be accessed by using an absolute directory path to the command:


Using the absolute path to any file in this way allows one to ignore any aliases which may have been defined, as well as the normal behaviour of the shell to search the user's defined path for the first instance of a command. This is a useful technique when performing actions as root since it ensures that the wrong command is not executing by mistake.

Network File System (NFS)

An important feature of UNIX is the ability to access a particular directory on one machine from another machine. This service is called the 'Network File System' (NFS) and the procedure itself is called 'mounting'.

For example, on the machines in Ve24, the directory /home is completely empty - no files are in it whatsoever (except for a README file which is explained below). When one of the Indys is turned on, it 'mounts' the /home directory from the server 'on top' of the /home directory of the local machine. Anyone looking in the /home directory actually sees the contents of /home on the server.

The 'mount' command is used to mount a directory on a file system belonging to a remote host onto some directory on the local host's filesystem. The remote host must 'export' a directory in order for other hosts to locally mount it. The /etc/exports file contains a list of directories to be exported.

For example, the following shows how the /home directory on one of the Ve24 Indys (akira) is mounted off the server, yet appears to an ordinary user to be just another part of akira's overall file system (NB: the '#' indicates these actions are being performed as root; an ordinary user would not be able to use the mount command in this way):

AKIRA 1# mount | grep YODA

YODA:/var/www on /var/www type nfs (vers=3,rw,soft,intr,bg,dev=c0001) YODA:/var/mail on /var/mail type nfs (vers=3,rw,dev=c0002)

YODA:/home on /home type nfs (vers=3,rw,soft,intr,bg,dev=c0003) AKIRA 1# ls /home

dist/ projects/ pub/ staff/ students/ tmp/ yoda/ AKIRA 2# umount /home

AKIRA 1# mount | grep YODA

YODA:/var/www on /var/www type nfs (vers=3,rw,soft,intr,bg,dev=c0001) YODA:/var/mail on /var/mail type nfs (vers=3,rw,dev=c0002)


AKIRA 3# ls /home README

AKIRA 4# mount /home AKIRA 5# ls /home

dist/ projects/ pub/ staff/ students/ tmp/ yoda/ AKIRA 6# ls /

CDROM/ dev/ home/ mapleson/ proc/ stand/ usr/ bin/ dumpster/ lib/ nsmail/ root.home tmp/ var/ debug/ etc/ lib32/ opt/ sbin/ unix*

Figure 7. Manipulating an NFS-mounted file system with 'mount'. Each Indy has a README file in its local /home, containing:

The /home filesystem from Yoda is not mounted for some reason. Please contact me immediately!

Ian Mapleson, Senior Technician.

3297 (internal) mapleson@gamers.org

After /home is remounted in Fig 7, the ls command no longer shows the README file as being present in /home, ie. when /home is mounted from the server, the local contents of /home are completely hidden and inaccessible.

When accessing files, a user never has to worry about the fact that the files in a directory which has been mounted from a remote system actually reside on a physically separate disk, or even a different UNIX system from a different vendor. Thus, NFS gives a seamless transparent way to merge different files systems from different machines into one larger structure. At the

department where I studied years ago [2], their UNIX system included Hewlett Packard machines running HP-UX, Sun machines running SunOS, SGIs running IRIX, DEC machines running Digital UNIX, PCs running an X-Windows emulator called Windows Exceed, and some Linux PCs. All the machines had access to a single large file structure so that any user could theoretically use any system in any part of the building (except where deliberately prevented from doing so via local system file alterations).

Another example is my home directory /mapleson - this directory is mounted from the admin Indy (Technicians' office Ve48) which has my own extra external disk locally mounted. As far as the server is concerned, my home account just happens to reside in /mapleson instead of

/home/staff/mapleson. There is a link to /mapleson from /home/staff/mapleson which allows other staff and students to access my directory without having to ever be aware that my home account files do not physically reside on the server.

Every user has a 'home directory'. This is where all the files owned by that user are stored. By default, a new account would only include basic files such as .login, .cshrc and .profile. Admin customisation might add a trash 'dumpster' directory, user's WWW site directory for public access, email directory, perhaps an introductory README file, a default GUI layout, etc.


UNIX Fundamentals: Processes and process IDs.

As explained in the UNIX history, a UNIX OS can run many programs, or processes, at the same time. From the moment a UNIX system is turned on, this process is initiated. By the time a system is fully booted so that users can login and use the system, many processes will be running at once. Each process has its own unique identification number, or process ID. An administrator can use these ID numbers to control which processes are running in a very direct manner. For example, if a user has run a program in the background and forgotten to close it down before logging off (perhaps the user's process is using up too much CPU time) then the admin can shutdown the process using the kill command. Ordinary users can also use the kill command, but only on processes they own.

Similarly, if a user's display appears frozen due to a problem with some application (eg.

Netscape) then the user can logon to a different system, login to the original system using rlogin, and then use the kill command to shutdown the process at fault either by using the specific process ID concerned, or by using a general command such as killall, eg.:

killall netscape

This will shutdown all currently running Netscape processes, so using specific ID numbers is often attempted first.

Most users only encounter the specifics of processes and how they work when they enter the world of application development, especially the lower-level aspects of inter-process

communication (pipes and sockets). Users may often run programs containing bugs, perhaps leaving processes which won't close on their own. Thus, kill can be used to terminate such unwanted processes.

The way in which UNIX manages processes and the resources they use is extremely tight, ie. it is very rare for a UNIX system to completely fall over just because one particular process has caused an error. 3rd-party applications like Netscape are usually the most common causes of process errors. Most UNIX vendors vigorously test their own system software to ensure they are, as far as can be ascertained, error-free. One reason why alot of work goes into ensuring programs are bug free is that bugs in software are a common means by which hackers try to gain root (admin) access to a system: by forcing a particular error condition, a hacker may be able to exploit a bug in an application.

For an administrator, most daily work concerning processes is about ensuring that system resources are not being overloaded for some reason, eg. a user running a program which is forking itself repeatedly, slowing down a system to a crawl.

In the case of the SGI system I run, staff have access to the SGI server, so I must ensure that staff do not carelessly run processes which hog CPU time. Various means are available by which an administrator can restrict the degree to which any particular process can utilise system resources, the most important being a process priority level (see the man pages for 'nice' and 'renice').


The most common process-related command used by admins and users is 'ps', which displays the current list of processes. Various options are available to determine which processes are

displayed and in what output format, but perhaps the most commonly used form is this:

ps -ef

which shows just about everything about every process, though other commands exist which can give more detail, eg. the current CPU usage for each process (osview). Note that other UNIX OSs (eg. SunOS) require slightly different options, eg. 'ps -aux' - this is an example of the kind of difference which users might notice between System V and BSD derived UNIX variants.

The Pipe.

An important aspect of processes is inter-process communication. From an every day point of view, this involves the concept of pipes. A pipe, as the name suggests, acts as a communication link between two processes, allowing the output of one processes to be used as the input for another. The pipe symbol is a vertical bar '|'.

One can use the pipe to chain multiple commands together, eg.:

cat *.txt | grep pattern | sort | lp

The above command sequence dumps the contents of all the files in the current directory ending in .txt, but instead of the output being sent to the 'standard output' (ie. the screen), it is instead used as the input for the grep operation which scans each incoming line for any occurence of the word 'pattern' (grep's output will only be those lines which do contain that word, if any). The output from grep is then sorted by the sort program on a line-by-line basis for each file found by cat (in alphanumeric order). Finally, the output from sort is sent to the printer using lp.

The use of pipes in this way provides an extremely effective way of combining many commands together to form more powerful and flexible operations. By contrast, such an ability does not exist in DOS, or in NT.

Processes are explained further in a later lecture, but have been introduced now since certain process-related concepts are relevant when discussing the UNIX 'shell'.

UNIX Fundamentals: The Shell Command Interface.

A shell is a command-line interface to a UNIX OS, written in C, using a syntax that is very like the C language. One can enter simple commands (shell commands, system commands, user-defined commands, etc.), but also more complex sequences of commands, including expressions and even entire programs written in a scripting language called 'shell script' which is based on C and known as 'sh' (sh is the lowest level shell; rarely used by ordinary users, it is often used by admins and system scripts). Note that 'command' and 'program' are used synonymously here.


Shells are not in any way like the PC DOS environment; shells are very powerful and offer users and admins a direct communication link to the core OS, though ordinary users will find there is a vast range of commands and programs which they cannot use since they are not the root user. Modern GUI environments are popular and useful, but some tasks are difficult or impossible to do with an iconic interface, or at the very least are simply slower to perform. Shell commands can be chained together (the output of one command acts as the input for another), or placed into an executable file like a program, except there is no need for a compiler and no object file - shell 'scripts' are widely used by admins for system administration and for performing common tasks such as locating and removing unwanted files. Combined with the facility for full-scale remote administration, shells are very flexible and efficient. For example, I have a single shell script 'command' which simultaneously reboots all the SGI Indys in Ve24. These shortcuts are useful because they minimise keystrokes and mistakes. An admin who issues lengthy and complex command lines repeatedly will find these shortcuts a handy and necessary time-saving feature. Shells and shell scripts can also use variables, just as a C program can, though the syntax is slightly different. The equivalent of if/then statements can also be used, as can case statements, loop structures, etc. Novice administrators will probably not have to use if/then or other more advanced scripting features at first, and perhaps not even after several years. It is certainly true that any administrator who already knows the C programming language will find it very easy to learn shell script programming, and also the other scripting languages which exist on UNIX systems such as perl (Practical Extraction and Report Language), awk (pattern scanning and processing language) and sed (text stream editor).

perl is a text-processing language, designed for processing text files, extracting useful data, producing reports and results, etc. perl is a very powerful tool for system management, especially combined with other scripting languages. However, perl is perhaps less easy to learn for a

novice; the perl man page says, "The language is intended to be practical (easy to use, efficient, complete) rather than beautiful (tiny, elegant, minimal)." I have personally never had to write a perl program as yet, or a program using awk or sed. This is perhaps a good example if any were required of how largely automated modern UNIX systems are. Note that the perl man page serves as the entire online guide to the perl language and is thus quite large.

An indication of the fact that perl and similar languages can be used to perform complex

processing operations can be seen by examining the humourous closing comment in the perl man page:

"Perl actually stands for Pathologically Eclectic Rubbish Lister, but don't tell anyone I said that."

Much of any modern UNIX OS actually operates using shell scripts, many of which use awk, sed and perl as well as ordinary shell commands and system commands. These scripts can look quite complicated, but in general they need not be of any concern to the admin; they are often quite old (ie. written years ago), well understood and bug-free.

Although UNIX is essentially a text-based command-driven system, it is perfectly possible for most users to do the majority or even all of their work on modern UNIX systems using just the


GUI interface. UNIX variants such as IRIX include advanced GUIs which combine the best of both worlds. It's common for a new user to begin with the GUI and only discover the power of the text interface later. This probably happens because most new users are already familiar with other GUI-based systems (eg. Win95) and initially dismiss the shell interface because of prior experience of an operating system such as DOS, ie. they perceive a UNIX shell to be just some weird form of DOS. Shells are not DOS, ie.:

 DOS is an operating system. Win3.1 is built on top of DOS, as is Win95, etc.

 UNIX is an operating system. Shells are a powerful text command interface to UNIX and not the OS itself. A UNIX OS uses shell techniques in many aspects of its operation.

Shells are thus nothing like DOS; they are closely related to UNIX in that the very first version of UNIX included a shell interface, and both are written in C. When a UNIX system is turned on, a shell is used very early in the boot sequence to control what happens and execute actions.

Because of the way UNIX works and how shells are used, much of UNIX's inner workings are hidden, especially at the hardware level. This is good for the user who only sees what she or he wants and needs to see of the file structure. An ordinary user focuses on their home directory and certain useful parts of the file system such as /var/tmp and /usr/share, while an admin will also be interested in other directories which contain system files, device files, etc. such as /etc, /var/adm and /dev.

The most commonly used shells are:

bsh - Bourne Shell; standard/job control - command programming language

ksh - modern alternative to bsh, but still restricted

csh - Berkeley's C Shell; a better bsh - with many additional features

tcsh - an enhanced version of csh

Figure 8. The various available shells.

These offer differing degrees of command access/history/recall/editing and support for shell script programming, plus other features such as command aliasing (new names for user-defined sequences of one or more commands). There is also rsh which is essentially a restricted version of the standard command interpreter sh; it is used to set up login names and execution environments whose capabilities are more controlled than those of the standard shell. Shells such as csh and tcsh execute the file

/etc/cshrc before reading the user's own .cshrc, .login and perhaps .tcshrc file if that exists.

Shells use the concept of a 'path' to determine how to find commands to execute. The 'shell path variable', which is initially defined in the user's .cshrc or .tcshrc file, consists of a list of

directories, which may be added to by the user. When a command is entered, the shell

environment searches each directory listed in the path for the command. The first instance of a file which matches the command is executed, or an error is given if no such executable command


is found. This feature allows multiple versions of the same command to exist in different locations (eg. different releases of a commercial application). The user can change the path variable so that particular commands will run a file from a desired directory.


echo $PATH

The list of directories is given.

WARNING: the dot '.' character at the end of a path definition means 'current directory'; it is dangerous to include this in the root user's path definition (this is because a root user could run an ordinary user's program(s) by mistake). Even an ordinary user should think twice about including a period at the end of their path definition. For example, suppose a file called 'la' was present in /tmp and was set so that it could be run by any user. Enterting 'la' instead of 'ls' by mistake whilst in /tmp would fail to find 'la' in any normal system directory, but a period in the path definition would result in the shell finding la in /tmp and executing it; thus, if the la file contained malicious commands (eg. '/bin/rm -rf $HOME/mail'), then loss of data could occur.

Typical commands used in a shell include (most useful commands listed first):

cd - change directory

ls - list contents of directory rm - delete a file (no undelete!) mv - move a file

cat - dump contents of a file

more - display file contents in paged format find - search file system for files/directories grep - scan file(s) using pattern matching

man - read/search a man page (try 'man man') mkdir - create a directory

rmdir - remove directory ('rm -r' has the same effect) pwd - print current absolute working directory

cmp - show differences between two files lp - print a file

df - show disk usage

du - show space used by directories/files mail - send an email message to another user

passwd - change password (yppasswd for systems with NIS)

Figure 9. The commands used most often by any user. Editors:

vi - ancient editor. Rarely used (arcane), but occasionally useful, especially for remote administration.

xedit jot

nedit - GUI editors (jot is old, nedit is - newer, xedit is very simple).




Related subjects :