UNIX and Linux - an introduction by Mathias Homann


Published on

As part of my job a senior Linux systems engineer and freelance consultant, I am often asked to do staff training on various Unix and linux related topics. One such training is “UNIX and Linux – an introduction”, a 2-day intensive course which I developed.

The content is aimed individuals who are familiar with Windows back-office operations.

Read More at http://linux.eregion.de/, Copyright © Penguins and stuff

Published in: Technology
  • Be the first to comment

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

UNIX and Linux - an introduction by Mathias Homann

  1. 1. UNIX and Linux an Introduction 2-day intensive training developed by Mathias Homann
  2. 2. Goals• provide insights on why UNIX matters• learn about what makes UNIX special• practice executing basic concepts• spark interest for deeper self-studyUNIX and Linux an Introduction, developed 2 of 71by Mathias Homann
  3. 3. Chapter Index• A short history of UNIX• UNIX today• Linux is not UNIX• How to access a UNIX system• Secure shell – SSH• SSH key management• Building tunnels with SSHUNIX and Linux an Introduction, developed 3 of 71by Mathias Homann
  4. 4. Chapter Index (2)• Learning details about UNIX commands• Shells and the environment• Internal and external commands• Interactive shells and startup scripts• Wildcards• Command aliasesUNIX and Linux an Introduction, developed 4 of 71by Mathias Homann
  5. 5. Chapter Index (3)• Paths• Finding files – locate vs find• Filesystems• Mounting• Links• Devices and drivers• Permissions and ownershipUNIX and Linux an Introduction, developed 5 of 71by Mathias Homann
  6. 6. Chapter Index (4)• Background processes• Scheduled processes• Processes and threads• Output and input redirection• Pipes• Shell historyUNIX and Linux an Introduction, developed 6 of 71by Mathias Homann
  7. 7. Chapter Index (5)• The power of grep• Less is more• The vi editor• Regular expressions• Sed – the stream editor• Awk – pattern scanner for text files• Writing your own scripts• Syslog and log filesUNIX and Linux an Introduction, developed 7 of 71by Mathias Homann
  8. 8. Chapter Index (6)• Finding facts about a system• Gathering statistics• Writing advanced scripts• More exercises• Useful commands• Higher wizardry – perl• Discussion and closingUNIX and Linux an Introduction, developed 8 of 71by Mathias Homann
  9. 9. A short history of UNIX Graphic credit: http://en.wikipedia.org/wiki/File:Unix.svgUNIX and Linux an Introduction, developed 9 of 71by Mathias Homann
  10. 10. A short history of UNIX (2)• 1969: Thompson, Ritchie and others start to “play with that unused PDP-7 in the corner” at Bell Labs, develop a system called “Unicks” based on Multics• 1971: UNIX was developed; first released version on March 11, 1971• 1975: Bourne shell introduced• 1982: SGI introduces IRIX, their commercial flavour of UNIX for their workstation line• 1983: SCO delivers their first packaged UNIX for Intel architecture PCs; Richard Stallman introduces the GNU operating system on September 27UNIX and Linux an Introduction, developed 10 of 71by Mathias Homann
  11. 11. A short history of UNIX (3)• 1986: HP releases HP-UX 1.0• 1987: SUN and AT&T form an alliance to work on what will be UNIX System V Release 4.0• 1990: IBM releases AIX• 1991: SUN releases Solaris OS, specially designed for symmetric multiprocessing• 1991: Linux Thorvalds sends his famous email to the minix developers mailing list, it starts with the words “Im doing a (free) operating system ...”UNIX and Linux an Introduction, developed 11 of 71by Mathias Homann
  12. 12. UNIX today• today, UNIX is the operating system of choice for both large server farms and small embedded devices• Amazon, Google, your android phone and your media center that is hooked up to your TV all run on Linux, a free UNIX-like operating systemUNIX and Linux an Introduction, developed 12 of 71by Mathias Homann
  13. 13. Linux is not UNIX• the open source community takes great joy in using “recursive acronyms”: – “GNU is not UNIX” – “Linux is not UNIX”• Linux is “UNIX-Like”• a lot in common, “UNIX-Compatible”, but also: – Not a serious, commercial development history / process – In a constant flow• UNIX is: – “carved in stone” before first deployment – commercially developed – Not free to use, unlike Linux, UNIX costs moneyUNIX and Linux an Introduction, developed 13 of 71by Mathias Homann
  14. 14. How to access a UNIX system• a “traditional” UNIX host usually has one local console, and several “dumb” terminals attached• today, such “dumb terminals” are usually PCs running terminal emulation software, instead of the old fashioned “true” serial consoles• a Linux system has one local physical console (keyboard and screen), with several virtual consoles available (usually six, to switch between them use the keyboard shortcuts ctrl-alt-F1 to ctrl-alt-F6)• virtual console #7 is usually occupied by the graphical desktop environment if such is usedUNIX and Linux an Introduction, developed 14 of 71by Mathias Homann
  15. 15. Secure shell – SSH• a better way to access a UNIX system is through SSH – The most common SSH client for Windows is called putty, available from http://www.chiark.greenend.org.uk/~sgtatham/putty/• SSH uses strong encryption – communication between the user and the system can not be eavesdropped on – the administrator password can not be intercepted – on the contrary, Telnet sends plaintext, unencrypted data over the network do not use telnet … ever• to access a UNIX system you need – a user account, and either have the password for that account – or have your SSH public key installed in the allowed keys list for that accountUNIX and Linux an Introduction, developed 15 of 71by Mathias Homann
  16. 16. Secure shell – SSH (2)• to login to a UNIX system through SSH, you use a command like this: ssh joe@example.host.com• useful commandline options for SSH: -1 and -2 to enforce SSH protocol version 1 or 2 -4 and -6 to enforce IPv4 or IPv6 -A enabled SSH agent forwarding (-a to disable) -X enable X11 forwarding (-x to disable) -C compresses data (useful on slower connections)UNIX and Linux an Introduction, developed 16 of 71by Mathias Homann
  17. 17. SSH key management• SSH uses an asymmetric key pair• to generate a key pair, use ssh-keygen on UNIX, or puttygen on Windows• the public key is what you install on servers that you need to access• the private key needs a passphrase to be used, and is the part that you need to keep safeUNIX and Linux an Introduction, developed 17 of 71by Mathias Homann
  18. 18. SSH key management (2)• the pass phrase for unlocking your private key can be significantly longer and more complex than a system password• to register your key for access to a system under one user account, append the content of your public key to ~/.ssh/authorized_keys• verify host keys by comparing the fingerprint of the host key with the fingerprint of the host key in your local known_hosts file• host keys do not change randomlyUNIX and Linux an Introduction, developed 18 of 71by Mathias Homann
  19. 19. Building tunnels with SSH• a tunnel is an encrypted “hole” that data can flow through• tunnels are used to create secure connections through firewalls• tunnels can be used to access services securely• a tunnel can: – forward a local port to the remote machine – a port on the remote machine to the local machine – a port on a machine in the same network as the remote machine to a port on the local machineUNIX and Linux an Introduction, developed 19 of 71by Mathias Homann
  20. 20. Building tunnels with SSH (2)• parameters for tunnels: -L x:host:y – forward localhost:x to host:y -R x:host:y – forward host:x to localhost:y• example: – a tunnel could be used to map the web server on a remote system to the local port 8080• this way, entering http://localhost:8080/ in your browser would access the remote serverUNIX and Linux an Introduction, developed 20 of 71by Mathias Homann
  21. 21. Building tunnels with SSH (3)• exercise – Generate your key pair with putty – Connect to (hostname) as (username) ← will have to be adapted for actual training environment – Forward the webserver running on the loopback interface on (hostname) to port 8080 on your local computer – Verify with your web browser that the tunnel worksUNIX and Linux an Introduction, developed 21 of 71by Mathias Homann
  22. 22. Learning about UNIX commands• UNIX has two built-in documentation systems: – info pages – man pages• to read the man page (manual page) of a given command, use man command – Try this out with man man• to look if there is a command that does something, try the apropos command• the apropos command lists the summary lines of all man pages that contain the term you specifiedUNIX and Linux an Introduction, developed 22 of 71by Mathias Homann
  23. 23. Learning about UNIX commands (2)• to look at what a certain command does without reading the whole man page, use whatis program• this prints out the summary only of the commands man page• to find where in the filesystem a command is, use the which commandUNIX and Linux an Introduction, developed 23 of 71by Mathias Homann
  24. 24. Shells and the environment• the shell is the interface to the system• the shell executes commands and shows the results• the “environment” is the total of stored settings inside a shell• important shell variables on UNIX systems: $PATH $PS1 $CWDUNIX and Linux an Introduction, developed 24 of 71by Mathias Homann
  25. 25. Shells and the environment (2)• UNIX knows several different shells: sh bash ksh zsh csh• the default shell on most Linux systems is bash• the set command shows all environment variables• change environment variables by assigning and exporting them• all exercises will use bash if not stated otherwiseUNIX and Linux an Introduction, developed 25 of 71by Mathias Homann
  26. 26. Internal and external commands• shells have built-in versions of most “system commands”• to “force” the use of a system command instead of the builtin, use the absolute path to the binary: /bin/ls• external commands are standardized• builtins differ from shell to shellUNIX and Linux an Introduction, developed 26 of 71by Mathias Homann
  27. 27. Interactive shells + startup scripts• an “interactive” shell is one that you type commands into• “non-interactive” shells are the ones that execute scripts• a “login” shell is the first interactive shell that gets started when you log in• the “profile” or “rc file” is a script that gets executed by a shell on startup• most shells execute more than one startup script, and execute a different set of scripts when started non- interactive, and yet another for the login shellUNIX and Linux an Introduction, developed 27 of 71by Mathias Homann
  28. 28. Interactive shells + startup scripts (2)• examples - the bash shell executes on startup as a login shell (in this order): /etc/profile ~/.bash_profile ~/.bash_login ~/.profile• if the bash shell is started interactively but not as a login shell it only executes ~/.bashrc• a non-interactive bash shell executes the file listed in $BASH_ENV if the variable is set and the file exists• note: a login bash executes ~/.bash_logout on exitUNIX and Linux an Introduction, developed 28 of 71by Mathias Homann
  29. 29. Wildcards• a wildcard is a pattern that describes a path or filename• wildcard expansion in shell commands happens on the shell level, before the actual command gets executed• different shells handle wildcards in different ways• exercises: – Which wildcard would mean “all jpeg files in this folder”? – Which pattern means “all jpeg files in this folder that start with the letter a”?UNIX and Linux an Introduction, developed 29 of 71by Mathias Homann
  30. 30. Command aliases• a command alias is a “placeholder” for a command and optionally one or more commonly used options• for example, on openSUSE Linux there is an alias “dir” which calls ls -l• a list of all aliases is shown by entering the alias command with no parameters• to see the aliases and wildcards expansion before commands get executed, enter set -xUNIX and Linux an Introduction, developed 30 of 71by Mathias Homann
  31. 31. Paths• paths on UNIX systems are all inside a “tree” of folders that starts at the “root” folder or / – the users home folder is usually held under /home and named after the username, e.g. /home/fred – the “search path” describes which folders to look in when a shell tries to find a command – the search path is stored in the environment variable $PATH – the minimal search path should contain /bin and /usr/bin – directories in the search path are separated by the colon: PATH=/bin:/usr/binUNIX and Linux an Introduction, developed 31 of 71by Mathias Homann
  32. 32. Everything is a file ...• ... not just a file• /proc/12345/status is a “virtual file” containing status information about process 12345• /dev/mem is a “device file” that is actually an interface to the systems memory• /dev/sg0 is a “device file” for the first “generic” SCSI device in a system• /dev/sdb5 is a “device file” that references the first logical partition on the second external, SCSI or SATA diskUNIX and Linux an Introduction, developed 32 of 71by Mathias Homann
  33. 33. Finding files – locate vs find• there are two ways to find a file, locate and find• the locate command uses a database of existing files which needs to be updated regularly, which usually happens once a day• the find command actually searches through the filesystem – this can take a while, but does not rely on a database that can be outdated locate can only search by shell wildcards find can search for anything, not just names• exercise: – find all files that changed since yesterdayUNIX and Linux an Introduction, developed 33 of 71by Mathias Homann
  34. 34. Filesystems• UNIX knows several different filesystems• one of the main differences is whether a filesystem is “journaling” or not• A journaling filesystem keeps track of the changes that will be made in a journal, before committing them to the main filesystem. In the event of a system outage, such filesystems are quicker to bring back online and less likely to be corrupted.• commonly used filesystems on Linux are: – ext2, ext3, ext4, jfs, xfs, reiserfs – Ext2 is the only of these that is not journalingUNIX and Linux an Introduction, developed 34 of 71by Mathias Homann
  35. 35. Filesystems (2)• filesystem limits: names paths filesize volume size ext2 255 unlimited 16GB - 2TB 2TB-32TB ext3 255 unlimited 16GB - 2TB 2TB-32TB ext4 256 unlimited 16GB - 16TB 1EB jfs 255 unlimited 8TB 512TB-4PB xfs 255 unlimited 8EB 8EB reiserfs 4032/226 unlimited 8EB 16TBUNIX and Linux an Introduction, developed 35 of 71by Mathias Homann
  36. 36. Mounting• all disk partitions need to be mounted to be accessible• a disk partition gets mounted into a folder, called the “mount point”• a UNIX system has a file with a list of all mount points that need to be mounted when the system starts: /etc/fstab – to mount a filesystem that is not listed in /etc/fstab you need superuser privileges – to access a partition you need to know its device node – device nodes are special files in /devUNIX and Linux an Introduction, developed 36 of 71by Mathias Homann
  37. 37. Mounting (2)• for example, the device node for a partition on a hard disk would be /dev/hda2 - meaning “the second primary partition on the first hard disk”• exercise: – explore what is mounted, and what is mounted on bootUNIX and Linux an Introduction, developed 37 of 71by Mathias Homann
  38. 38. Links• a link is a “pointer” to a file – can be a “soft” or a “hard” link – a softlink is a pointer at a file, and can link across filesystems – a hardlink is another directory entry that points at the same starting sector of the filesystem• hardlinks are only possible within one filesystem, and cannot point at directories• links are created with the ln command ln creates hardlinks by default – for softlinks use the -s option• exercise: – create a link to /usr/bin/bash in ~/bin/UNIX and Linux an Introduction, developed 38 of 71by Mathias Homann
  39. 39. Devices and drivers• every piece of hardware is accessed through a device file under /dev• examples: /dev/hda - the first IDE harddisk /dev/sdb - the second SCSI or SATA disk /dev/nvidia – an NVIDIA graphics card /dev/dsp0 – the sound cardUNIX and Linux an Introduction, developed 39 of 71by Mathias Homann
  40. 40. Devices and drivers (2)• access to hardware is governed by the file permissions on those special files• for example, the permissions on a graphics card could be set to allow only root and anyone in the group “video” access to write to it, therefore only users in the group “video” would be able to run 3d accelerated applications• exercise: – find out which group has write access to the cd/rw drive, e.g. would have sufficient permissions to use a CDRW writer on the systemUNIX and Linux an Introduction, developed 40 of 71by Mathias Homann
  41. 41. Permissions and ownership• there are 3 levels of ownership of any file: – “owner” – “group” – “others”• permissions on a file: – read, write, execute, separately for all three owner types• example: – a file usually is read/write for the owner, and read-only for anyone else: -rw-r--r--• change the owner: chown username file• change the group: chgrp groupname file• change permissions: chmod <permissions> fileUNIX and Linux an Introduction, developed 41 of 71by Mathias Homann
  42. 42. Background processes• UNIX can run commands in the background so that you can do something else – To execute a program in the background, end the commandline with & – To send a running program to the background, press ctrl-z and enter bg – To view the list of running background processes, enter jobs• when you logout while you still have background processes running, they will be killed unless you started them with nohup: nohup sleep 10000 will run sleep 10000 in the background – the output of the command will be written to nohup.outUNIX and Linux an Introduction, developed 42 of 71by Mathias Homann
  43. 43. Scheduled processes• to run a program at regular intervals, use cron• cron keeps lists of scheduled jobs• edit the list with crontab -e• to run a program at a certain time once, use at at 23:00 asks for a sequence of commands• the job gets deleted once it runsUNIX and Linux an Introduction, developed 43 of 71by Mathias Homann
  44. 44. Processes and threads• a process is one running executable – A single process can have more than one running thread – To see all processes, use top, htop, or the ps command – To send signals to processes, use the kill command• several “levels” of “kill signal”, ordered by “lethality”: kill -HUP tells a process to shut down nicely kill -QUIT – the same but a bit more urgent kill -KILL kills a process kill -l lists all possible signals with name and numeric value kill -9 is equivalent to kill -KILL• combined exercise: – start a process in the background that waits for 10 minutes – kill it before the time is overUNIX and Linux an Introduction, developed 44 of 71by Mathias Homann
  45. 45. Output and input redirection• in- and Output can be redirected with the < and > symbol• redirect input: cat < /tmp/file.txt• redirect output: cat < /tmp/file.txt > /tmp/foo.bar• redirect the error output: sort < foo 2>/dev/nullUNIX and Linux an Introduction, developed 45 of 71by Mathias Homann
  46. 46. Pipes• pipes are used to direct the output of one command to the input of another• pipes use the pipe symbol: |• example: ls -la | less pipes the output of the ls command into the less pager• exercise: sort the content of the passwd file by alphabetUNIX and Linux an Introduction, developed 46 of 71by Mathias Homann
  47. 47. Shell history• UNIX shells keep track of your commands• to browse through this list use the cursor up and cursor down keys• to re-execute a previous command, find it in your history and press enter• to find a previous command more quickly, press ctrl-r and start typing; the history will “jump” to the newest match of what youre typingUNIX and Linux an Introduction, developed 47 of 71by Mathias Homann
  48. 48. Shell history (2)• to view the whole history, use the “history” command• to re-execute a certain command, find its number in the history, then enter !number, e.g. !514 to re-run number 514 from your history• to search in your history: press ctrl-r, then start typing• exercise: – use a few commands (ls, man, ls -l, ls -la) then view the history, then re-run some of them, then search in your historyUNIX and Linux an Introduction, developed 48 of 71by Mathias Homann
  49. 49. The power of grep• grep searches for text in files• grep can use regular expressions• grep has many options - read the man page• most useful options: – -i for “search case insensitive”, and -v for “inverse” or “search for anything that does not match my search string”• example: grep myusername /var/log/messages – find all lines in logfile that contain myusername• exercise: – filter the main system logfile for all lines from last MondayUNIX and Linux an Introduction, developed 49 of 71by Mathias Homann
  50. 50. Less is more• less is a “pager” to view large text files on screen• less can search for text: – press : then enter a slash followed by your text• less can switch to “continuous refresh” to refresh a file that is still being written; press F to switch• less can read from “stdin”; pipe commands into it to paginate the output• g and g jump to the end and the start of the file• to search in less, type /searchterm• to jump to a line number, type :number• example: less /var/log/messages• exercise: – display the content of /usr/bin in lessUNIX and Linux an Introduction, developed 50 of 71by Mathias Homann
  51. 51. The vi editor• the editor vi exists on every UNIX system• vi has two modes: insertion mode and command mode – The editor begins in command mode, where the cursor movement and text deletion and pasting occur – Insertion mode begins upon entering an insertion or change command – [ESC] returns the editor to command mode (where you can quit, for example by typing :q!)• most commands execute as soon as you type them except for "colon" commands which execute when you press the return key• nifty: vi does syntax highlighting; activate with :syntaxUNIX and Linux an Introduction, developed 51 of 71by Mathias Homann
  52. 52. The vi editor (2)• quitting vi: :x Exit, saving changes :q Exit as long as there have been no changes ZZ Exit and save changes if any have been made :q!Exit and ignore any changes• switching to edit mode: i – insert r – replace a – appendUNIX and Linux an Introduction, developed 52 of 71by Mathias Homann
  53. 53. The vi editor (3)• cursor movement• cursor keys, and: ^ or 0 – move to start of line $ - move to end of line• block and line operations: dd – delete line yy – copy line p – paste lineUNIX and Linux an Introduction, developed 53 of 71by Mathias Homann
  54. 54. Regular expressions• regular expressions are powerful string matching patterns• examples: . - any one character * - any repetitions of the pattern left of the star .* - any number of any characters [:upper:] - all UPPER CASE characters n – newline [a-q] – any letter between a and qUNIX and Linux an Introduction, developed 54 of 71by Mathias Homann
  55. 55. Regular expressions (2)• more info:• the “Regular expressions cheat sheet v2” – http://www.addedbytes.com/cheat-sheets/regular-expressions- cheat-sheet/• example: – a regular expression cat.*dog matches any string that has “cat” and “dog” in it with any other characters in between them, but only in that order!UNIX and Linux an Introduction, developed 55 of 71by Mathias Homann
  56. 56. Sed – the stream editor• Sed reads text from stdin, does edit operations on it, and prints the result on stdout• examples: sed -e s/red/green/g <colors.txt >colors1.txt – replaces all occurrences of “red” with “green”• exercise: – read the man page, then write a text file, then replace all “the” with “THE”• exercise: – print out each directory in the path variable in a new lineUNIX and Linux an Introduction, developed 56 of 71by Mathias Homann
  57. 57. Awk – pattern scanner for text files• Awk scans text files for patterns and operates on them• examples: awk {print $2“n“} < file.txt – print the second word of every line of file.txt• exercise: – read the man page, then use vi to write a text file with a few lines of the format: Username:Firstname:Lastname:Telephone number – then, use awk to convert this into ldap syntax: dn: uid=Username, dc=example, dc=com cn: Firstname Lastname sn: Lastname telephoneNumber: Telephone numberUNIX and Linux an Introduction, developed 57 of 71by Mathias Homann
  58. 58. Writing your own scripts• scripts can be written with any text editor• scripts dont need a special filename suffix• scripts need to be executable (hint: chmod)• scripts can explicitly state which shell should be used to execute it by putting the “hashbang” for the shell in the first line: #!/bin/bash – a bash script #!/bin/csh – a c shell script #!/bin/sh – a “sh” shell script• “sh” is the most basic shell; exists on any UNIX• exercise: – write a script that prints “hello world” ten timesUNIX and Linux an Introduction, developed 58 of 71by Mathias Homann
  59. 59. Syslog and log files• syslog is a UNIX daemon that collects and handles log file messages• syslog handles messages according to severity and facility• details: see man page• syslog can write messages to one or more files depending on severity and facilityUNIX and Linux an Introduction, developed 59 of 71by Mathias Homann
  60. 60. Syslog and log files (2)• logfiles usually exist in /var/log• the syslog configuration file is in /etc and states which facility.severity goes in which file• exercise: – check the syslog configuration to see which files hold messages of failed logins – then check if there were any recent failed login attemptsUNIX and Linux an Introduction, developed 60 of 71by Mathias Homann
  61. 61. Finding facts about a system• most Linux systems have a file in /etc/ that contains information about which distribution is running – for example, /etc/redhat-Release uname -a prints out information about the system• use mount and df to find out about disk sizes and mount points• a lot of information is in /proc• almost all configuration files are in /etc and its subdirectoriesUNIX and Linux an Introduction, developed 61 of 71by Mathias Homann
  62. 62. Finding facts about a system (2)• most UNIX systems use some form of software package management – the list of installed packages can tell you a lot about the purpose of a system – on Linux there are two widely used package management systems, rpm and apt/dpkg – rpm is used on openSUSE, redhat, and their derivatives and commercial versions – on debian, ubuntu and derivatives, apt and dpkg is used – commands such as rpm -qa and dpkg –get-selections show the list of installed packages – these lists are long, less is your friendUNIX and Linux an Introduction, developed 62 of 71by Mathias Homann
  63. 63. Finding facts about a system (3)• to list all loaded kernel modules lsmod• use insmod or modprobe to load additional kernel modules into a running system• use modprobe -r to remove a module and all dependencies from a running system• most of them are hardware drivers or drivers for “features”UNIX and Linux an Introduction, developed 63 of 71by Mathias Homann
  64. 64. Gathering statistics• commands to explore the status of the system vmstat and free show memory usage iostat shows drive accesses netstat shows network statistics netstat can also show active network connections and listening processes; read the man page• exercise: – check how much memory the machine has, and how much is used; then check how many active network connections exist that are not SSH connectionsUNIX and Linux an Introduction, developed 64 of 71by Mathias Homann
  65. 65. Writing advanced scripts• scripts can do math: a=$(($b+$c))• scripts can have flow control – if (condition) then {command; command;}; else { command; command;}; endif – do { command; command; } while (condition); – for (iterator); do { command; command; } done;• scripts can have functions• scripts can return values to the calling processUNIX and Linux an Introduction, developed 65 of 71by Mathias Homann
  66. 66. Writing advanced scripts (2)• exercise: – write a script that: – finds all log files under /var log – takes all files older than 2 days – prints their name, size and age – (size in human readable format, 1024k = 1 M etc)UNIX and Linux an Introduction, developed 66 of 71by Mathias Homann
  67. 67. More exercises• create a file “a”, write “hello world” into it, then hardlink it as “b”• check the inodes of both files – (hint: theres an option for ls that does that)• create a softlink “c” to “a”, check inodes• run tail -f /var/log/messages, send it to the background, edit a different file in vi, exit vi, bring the tail command back to the front• compare the differences between the various ps output formats: ps –ax ps -ef ps -axf – sort /etc/passwd alphabetically – sort it by uidUNIX and Linux an Introduction, developed 67 of 71by Mathias Homann
  68. 68. Useful commands• cd – change directory• pushd – change directory but it stores the previous directory on a fifo stack• popd – returns to previous directory from the stack• cat – read from file or stdin, write to file or stdout (example: cat /etc/motd to print that file to screen)• cp – copy files• mv – move / rename files• head & tail – print the first or last lines of a file• find – search for filesUNIX and Linux an Introduction, developed 68 of 71by Mathias Homann
  69. 69. Useful commands (2)• less – display a file in a pager• grep – search for text in files• sed – command-line editing of files• wc – count lines/words/characters in files• df – disk free (shows free space in partitions)• du – disk usage (adds up file sizes, more accurate than df, takes some time to finish)• gzip – compress files, use gunzip to decompress• diff – compare filesUNIX and Linux an Introduction, developed 69 of 71by Mathias Homann
  70. 70. Higher wizardry – perl• perl is disputedly the most powerful, simple, complicated, and obscurely easy to understand scripting language• perl is enough for its own workshop day :)UNIX and Linux an Introduction, developed 70 of 71by Mathias Homann
  71. 71. Discussion and closing• questions• comments• Instructor Evaluation FormUNIX and Linux an Introduction, developed 71 of 71by Mathias Homann