Diese Seite wurde von der entsprechenden Seite der MandrivaUser.de wiki kopiert.
Grundlagen Unix/Linux
1. Geschichte Unix/Linux
- 1969 AT&Ts Bell Laboratories Multix-Projekt - Ken Thompson entwickelt Unics (später Unix) auf der Grundlage von Multics - Brian Kernigan & Dennis Richie entwickeln C - 1973 Unix wird in C portiert - 1976 wurde der Quellcode an Universitäten freigegeben - Anfang der 80er - viele große Firmen kauften Lizenzen und schrieben ihr eigenes Linux - kommerzielle Unix-Varianten entstanden:
AIX von IBM HP-UX von HP Sinix von Siemens Nixdorf Solaris von Sun (jetzt Oracle) UnixWare von Novell SCO-Unix von SCO Xenix von Microsoft Unix System V von AT&T BSD-Unix von Berkeley University of California (BSD=Berkeley Software Distribution)
- 1982 gründet Richard Stallman die FSF (Free Software Foundation) mit dem Ziel, Open Source Software zu entwickeln, zu fördern und zu verbreiten - GNU Projekt der FSF entwickelte GNU C-Compiler (GCC) und Unix-Systemprogramme unter der GPL-Lizenz (General Public License) - 1991 entwickelt der finnische Student Linus Torvalds Betriebssystem-Kern auf der Basis von Minix, veröffentlicht Quellcode im Internet, Linux-Kernel in Version 0.01 - Dateisystem wurde Minix entnommen - In Kombination mit vielen GNU-Softwareprojekten und anderen OpenSource-Programmen entstanden Mitte der 90er viele Linux-Distributionen
Redhat / Fedora Core Novell Suse / OpenSuse Debian Slackware Mandriva ...
2. Leistungsmerkmale
- Multitasking (echtes, preemptives) - mehrere Prozesse teilen sich den Prozessor, laufen quasi parallel (für kleine Zeitscheiben bekommt man Prozessorzeit) - Multiuserbetrieb (mehrere angemeldete Benutzer gleichzeitig) - Demand Paging - Auslagerung von Speicherseiten des Arbeitsspeichers auf swap-Partition - hierarchisches Dateisystem, über mehrere Datenträger möglich - einheitliche Geräteschnittstellen in Form von Gerätedateien - Redirection (Umleitung) von Ausgaben und Eingaben (bspw. in Dateien) - Piping (Pipelining) - umleiten der Ausgabe eines Befehle an die Eingabe des folgenden - Chaining - verketten von Befehlen - Hintergrundverarbeitung von Prozessen - hohe Portierbarkeit auf andere Plattformen
2.1 Aufbau von Linux
Linux besteht im wesentlichen aus 3 Komponenten: - Kernel (Betriebssystemkern) - Befehlzeileninterpreter (Shell) - Dienstprogramme (Systemtools und Anwendungen)
Im Kernel sind die Aufgaben des OS realisiert - Kommunikation mit der Hardware - Verwaltung der Ressourcen - Bereitstellung der Dateisysteme - Unterbrechungssteuerung
Shell als Befehlzeileninterpreter - liest die eingegebenen Befehle, startet Programme, zeigt Ergebnisse an - verschiedene Shells (sh, bash, dash, ksh, csh, tcsh ...) Bourne Shell (sh) usprüngliche Unix-Shell C-Shell (csh) weitere Unix-Shell Korn-Shell (ksh) Weiterentwicklung von Bourne- und C-Shell Bourne Again Shell (bash) weitverbreitetste Shell - stellt eine umfangreiche Programmiersprache zur Verfügung - stellt einen konfigurierbaren Eingabeprompt dar Bsp: meier@lx-71-21:~> Benutzername@Hostname Pfadangabe Promptzeichen Pfadangabe: ~ für /home des angemeldeten Benutzers Promptzeichen: $ für Benutzerprompt
# für root-Prompt Opensuse benutzt > für Benutzerprompt
3. An- und Abmelden
- Systeme mit grafischer Oberfläche bieten die grafische Anmeldung in einem Displaymanager, z.B. kdm für KDE - anschließend wird eine grafische Oberfläche geladen, z.B. KDE-Desktop - neben der grafischen Oberfläche stehen 6 Textkonsolen (tty's, Terminals) zur Verfügung - Wechsel von X-Server zu einer Textkonsole mit Strg+Alt+Fn (n = 1-6) - Wechsel von Textkonsole zum X-Server mit Strg + Alt + F7 - nach Eingabe von Benutzername und Passwort wird eine Login-shell gestartet - Abmelden von der Shell / Beenden der Shell o $exit (beliebige Shell beenden) o $logout (abmelden und beenden nur für Login-Shell) o Strg + D (ASCII-Steuercode für EOF [End of File])
3.1 Das X-Window-System (kurz X)
Fenstermanager: o TWM o IceWM o Metacity o Kwin4 o Compiz / Emerald o ...
Desktopsysteme o KDE o GNOME o XFCE o LXDE o E17 o ...
X-Window-System - ist Sammlung von Funktionen und Protokollen - Grundlage für grafische Ein- und Ausgaben - netzwerkfähig & netzwerktransparent, Client-Server-System
X-Server - Schnittstelle zwischen X-Window-System und der Hardware
X-Client - Programme die den X-Server für grafische Ein- und Ausgaben nutzen
Display Manager - Programm, dass das grafische Login ermöglicht, Bspw: XDM, KDM, GDM
Window Manager - Programm dass die Fenster für die X-Clients verwaltet, Bspw: kwin4, metacity - bestimmt Aussehen und Funktionalität
Desktop-System (Desktop-Environment) - bringt eine große Sammlung von Anwendungsprogrammen mit - vereinheitlicht Aussehen (Menüs,Symbole) und Bedienung (Drag&Drop, Shortcuts) - Anwendungsprogramme basieren auf der gleiche Grafikbibliothek Bspw: QT, GTK
Virtueller Bildschirm - die Auflösung des Desktops ist größer als die des Monitors - auf dem Monitor ist nur ein Ausschnitt des Desktops zu sehen, der automatisch scrollt, wenn die Maus den Bildschirmrand berührt
Virtueller Desktop - eine Anwendung des Desktopsystems um zwischen mehreren Desktops zu wechseln
3.2 Starten des X-Servers
Bei der Installation wird der Funktionsumfang beim Starten des Systems in sogenannten Runleveln festgelegt
Runlevel 3 – Konsolenanmeldung (Kein X-Server starten) Runlevel 5 – Grafische Anmeldung (X-Server + Displaymanager starten)
3.3 Manuelles Starten des X-Servers
- Wechsel in den Runlevel 3 => Beenden von X-Server und Displaymanager <strg> + <alt> + <F1> => Textkonsole als Root anmelden #init 3 - Starten der X-Session für benutzer <alt> + <F2> als benutzer anmelden $startx
4. Einfache Befehle und ihre Argumente
4.1 einfache Befehle - $ = Symbolik für Benutzer-Shellprompt
$who = zeigt alle momentan angemeldeten Benutzer an $clear = löscht Bildschirm der Konsole $date = zeigt aktuelles Datum/uhrzeit $whoami = zeigt aktuellen Benutzer an $cal = zeigt Kalender $bc = interaktiver Taschenrechner $su = startet eine Subshell im Kontext eines anderen Benutzers
(ohne Argument: root-Shell mit Passwortabfrage)
4.2 Befehle und ihre Argumente
- Argumente werden durch Leerzeichen getrennt hinter dem Befehl angegeben - normale Argumente sind i.d.R Daten, die dem Programm übergeben werden (Dateiname, Zeichenkette) Bsp: $cal 2010 - Jahreskalender 2010
$su user1 - Subshell als user1 $echo "Hallo Welt" - Ausgabe von Hallo Welt auf Konsole
- Optionen sind eine Art Schalter, die die Funktionsweise eines Befehle erweitern oder spezialisieren - Unix-Optionen (AT&T) sind einzelne Zeichen, die mit einem "-" beginnen Bsp: $bc -h - Help
$cal -m - Montag $cal -3 - 3 Monate $cal -m -3 = cal -3m
- GNU-Optionen sind Optionswörter, die mit "--" beginnen Bsp: $bc --help - BSD-Optionen sind einzelne Zeichen ohne "-" Bsp: $ps a - Kombination von Optionen und normalen Argumenten Bsp: $cal --help
$cal [-13...] [[[day] month] year] 4.3 Unterscheidung zwischen Shell-Befehlen und Systemprogrammen
$which Befehl -bei Systemprogrammen Pfadangabe, bei Shell-Builtins keine Ausgabe $type Befehl -bei Systemprogrammen Pfadangabe, bei Shell-Builtins shell builtin / shell keyword $whereis Befehl -Pfad zu Programmen/Man-Pages ausgeben $whatis Befehl -Kurzbeschreibung zu Befehlen angeben
5 Online-Hilfen
- Unix-Manuals (Handbücher) zu sämtlichen Befehlen und Konfigurationsdateien werden Man-Pages mit installiert Aufruf: $man [Abschnitt] thema Bsp: $man cal
$man 1 passwd - Handbuch zum befehl passwd $man 5 passwd - Handbuch zur Systemdatei /etc/passwd
Das man-pages-System ist inhaltlich in Abschnitte gegliedert Die folgende Tabelle zeigt die Nummern der Abschnitte der Manualseiten gefolgt vom Typ der dort zu findenden Seiten.
0 Dateiheader (gewöhnlich in /usr/include)
1 Ausführbare Programme oder Shellbefehle
2 Systemaufrufe (Kernelfunktionen)
3 Bibliotheksaufrufe (Funktionen in System-Bibliotheken)
4 Spezielle Dateien (gewöhnlich in /dev)
5 Dateiformate und Konventionen, z. B. /etc/passwd
6 Spiele
7 Makropakete und Konventionen, z. B. man(7), groff(7)
8 Systemadministrationsbefehle (in der Regel nur für root)
9 Kernelroutinen [Nicht Standard]
n neu [veraltet]
l lokal [veraltet]
p öffentlich [veraltet]
o alt [veraltet]
- zur Anzeige der man-Pages wird das Programm less [Pager] verwendet Navigation innerhalb von less: Leertaste - Seite vor Backspace - Seite zurück g - zum Anfang (erste Zeile) der Seite G - zum Ende (letzte Zeile) der Seite nG - zur n-ten Zeile /Suchbegriff- Suchen nach Suchbegriff (erste Fundstelle)
n - nächste Fundstelle N - vorherige Fundstelle
q - Quit - Hinweis: apropos thema liefert eine Liste verfügbarer Man-Pages zu einem Thema
- GNU Infosystem - bietet Querverweise (Links) zu anderen Themen (Dokumenten) Aufruf: $info thema Bsp: $info date - Querverweise sind mit * gekennzeichnet Navigation innerhalb von info Leertaste - Seite vor Backspace - Seite zurück Tab - springen zum nächsten Querverweis Enter - folgt dem Querverweis l - zurück zum letzten angewählten Querverweis h - Hilfe zur Bedienung u - eine Hierarchieebene nach oben n - nächste Infoeinheit p - vorherige Infoeinheit (der gleichen Hierarchie) q - Quit - Hilfe anzeigen im Dolphin/Konqueror: man: in Adresszeile eintragen
- Hilfe im KDE-Hilfecenter anzeigen: Alt+F2 -> khelpcenter oder K-Menü -> System -> Hilfe starten Unix-Hilfeseiten anwählen
6 Grundlagen der Dateiverwaltung
- Aufbau des Dateisystems als Dateisystem werden eingesetzt: - ext2 (lange Zeit Standard, kein Journaling) - ext3 (momentan Standard, Journaling, abwärtskompatibel) - ext4 (relativ neu, zusätzliche Funktionen wie extents, Online-Defragmentierung, abwärtskompatibel) - ReiserFS (Entwicklung eingestellt, Journaling, inkompatibel zu ext) alle Dateien werden in einer Inode-Tabelle verwaltet Die Journalingfunktion protokolliert Schreibzugriffe auf geöffnete Dateien Nach einem Systemabsturz kann somit eine schnellere Überprüfung und Wiederherstellung eines konsistenten Dateisystem erfolgen - logischer Aufbau - hierarchisches System, das mit der wurzel (root) "/" beginnt - Pfadangaben werden mit "/" getrennt - Groß- und Kleinschreibung werden unterschieden - Dateinamen können max. 255 Zeichen lang sein - Sämtliche Zeichen außer “/“ sind erlaubt - Dateinamenserweiterungen haben keine funktionale Bedeutung
Dateitypen Typ Symbol normale Datei - Verzeichnis d Gerätedatei blockorientiert b Gerätedatei zeichenorientiert c Symbolische Links l named pipes p zur Interprozesskommunikation sockets s zur Interprozesskommunikation
- Linux Standardverzeichnisstruktur (siehe auch FHS - Filesystem Hierarchy Standard)
/ root Verzeichniswurzel |-bin elementare Befehle für alle Benutzer (binaries) |-boot Linux-Kernel (vmlinuz) und Bootmanager |-dev Gerätedateien (devices) |-etc Konfigurations- und Administrationsdateien |-home Homeverzeichnis der Benutzer |-lib(64) Systembibliotheken und Kernelmodule (libraries) |-lost+found Dateifragmente nach Dateisystemprüfung, wenn beschädigt |-media zum Einhängen entfernbarer Datenträger (Floppy,CDROM,USB-Sticks usw.) |-mnt zum temporären Einhängen v. Datenträgern (mount) |-opt optionale Anwendungsprogramme (Adobe Reader, TeamViewer, KDE3 unter OpenSuse usw.) (optional) |-proc virtuelles Dateisystem, Informationen über laufende Prozesse (process) |-root Homeverzeichnis des Benutzers root |-sbin elementare Systembefehle und Dienste für root (system binaries) |-srv Daten für Serverdiensten (WWW, FTP usw.) (server) |-sys virtuelles Dateisystem, Informationen zur aktiven Hardware |-tmp temporäre Dateien (temporary) |-usr Unix System Ressources - Programme, Programmdaten, Bibliotheken, Handbücher, Sounds, Bilder |-var veränderliche Dateien z.B. Logdateien, Cache usw. (variabel)
Hinweis: mehrere dieser Verzeichnisse können auf externe Dateisysteme (Partitionen) verweisen z.B. /boot, /home, /usr, /var Warnung: nicht ausgelagert werden dürfen /bin, /sbin, /root, /lib, /etc
7 Wichtige Befehle zur Dateiverwaltung
- spezielle Verzeichnissymbole ~ -> verweist auf Homeverzeichnis des aktuellen Benutzers / -> verweist auf Wurzelverzeichnis . -> verweist auf aktuelles Verzeichnis .. -> verweist auf Elternverzeichnis des aktuellen Verzeichnisses - Befehle für Verzeichnisse $pwd - print working directory, zeigt aktuellen Verzeichnispfad an $ls [optionen] [dateiname] - zeigt Inhalt eines Verzeichnisses an
-a - zeigt alle Dateien, auch versteckte (beginnen mit einem "." im Namen) -A - dito, ohne "." und ".."-Verwaltungseinträge
$cd [verzeichnis] - change directory, Verzeichnis wechseln
- - in zuletzt besuchtes Verzeichnis wechseln
$mkdir [optionen] verzeichnisname - erstellt verzeichnisse
-p - Elternverzeichnisse erstellen, falls nicht vorhanden
$rmdir verzeichnisname - löscht Verzeichnisse, falls leer
-p - löscht Elternverzeichnisse mit, falls auch leer
$cat dateiname - zeigt Dateiinhalt an, fügt Dateien aneinander (concatenate) $more dateiname - zeigt Dateiinhalt seitenweise (Abbruch mit Strg+C) $less dateiname - zeigt Dateiinhalt mit Navigationsmöglichkeit (Abbruch mit Strg+C oder q, siehe man) $touch dateiname - erzeugt leere Dateien bzw. ändert Zeitstempel bestehender Dateien $cp [optionen] quelle ziel - kopiert Quelle nach Ziel Bsp: cp /etc/services tmp - wenn Zielname nicht existiert, wird er der neue Dateiname
cp -R - rekursiv (mit Unterverzeichnissen und Dateien) kopieren Hinweis: als Quelle können mehrere Dateien/Verzeichnisse angegeben werden, das Ziel muss dann ein Verzeichnis sein
$mv quelle ziel - verschiebt/benennt Quelle nach Ziel um $rm [optionen] datei - löscht Dateien und komplette Verzeichnisse
-r - löscht Verzeichnisse -i - interaktiv: fragt vor dem Löschen nach
- Verwendung von Links (Verküpfungen) Für existierende Dateien wird ein zusätzlicher Name vergeben, über den alternativ sämtlichen Dateioperationen ausgeführt werden können Man unterscheidet Zwei Arten von Links: Hardlinks und Softlinks
- Hardlinks
- können nur für Dateien (keine Verzeichnisse) angewendet werden
- in einem Verzeichnis wird ein weiterer Namenseintrag für einen bestehenden Inode (Datei)
erstellt, wobei der Linkzähler um 1 erhöht wird
- beim Löschen eines Dateinamens wird der Linkzähler um 1 verringert,
ist der Zähler 0, wird die Datei (Inode) physisch gelöscht
- Hardlinks können nur innerhalb des gleichen Dateisystems verwendet werden
- verbrauchen keinen Platz
- man kann nicht unterscheiden zwischen Hardlink und originaler Datei
$ln zielname zusätzlicher_name
- Symbolische Links
- entsprechend weitesgehend Verknüpfungen unter Windows
- für einen Symlink wird eine neue Datei (Inode) erstellt,
deren Inhalt enthält den Pfad zur referenzierten Datei/Verzeichnis
- können auf Dateien/Verzeichnisse verweisen, auch auf anderen Dateisystemen
- werden häufig aus Kompatibilitätsgründen für Systemverzeichnisse / Dateien verwendet
- verbrauchen Speicherplatz
$ln -s zielname link_name
8 Erweiterte Möglichkeiten der Shell
- Expandierung von Dateinamen / Verwenden von Metazeichen (Wildcards) um mehrere Dateien/Verzeichnisse in Befehle zu verwenden, können Metazeichen verwendet werden * - steht für beliebige Anzahl beliebiger Zeichen Bsp: $ls -ld /etc/i* alle Namen die mit "i" beginnen ? - steht für genau ein beliebiges Zeichen Bsp: $ls -ld /etc/???.* 3 Zeichen.belibige Erweiterung [...] - genau ein Zeichen aus der Auflistung Bsp: $ls -ld /etc/[iIgG]* Namen die mit einem i oder I oder G beginnen
$ls -ld /etc/???[0-9]* alle Namen mit einer Ziffer an 4. Stelle $ls -ld /etc/???[0-49]* an 4. Stelle die Ziffer 0,1,2,3,4,9 (0 bis 4 oder 9)
[!...] - genau ein beliebiges Zeichen, außer denen in der Auflistung [^...] - genau ein beliebiges Zeichen, außer denen in der Auflistung Bsp: $ls -ld /etc/[!a-dhi]* alle Namen die nicht mit a,b,c,d,h,i beginnen - Maskieren von Metazeichen \ - hebt die Bedeutung des nachfolgenden Metazeichens auf (auch Leerzeichen) Bsp: $touch file\? "..." - hebt die Bedeutung sämtlicher Metazeichen im String auf Bsp: $touch "fil* 1.?"
- Ein- und Ausgabeumleitung
Die Shell ermöglicht es Eingaben der Tastatur u. Ausgaben auf den Bildschim aus/in Dateien umzuleiten
- Spezialgeräte (Streams)
Bezeichnung Name Gerät Deskriptor Zeichen zur Umleitung
Standardeingabe stdin Tastatur 0 < (0<)
Standardausgabe stdout Bildschirm 1 > (1>) >> (1>>)
erstellt neue Datei erstellt neue Datei löscht wenn vorhanden anhängen wenn vorhanden
Standardfehlerausgabe stderr Bildschirm 2 2> 2>>
Bsp: Umleitung stdin:
Der Befehl cat liest von der Standardeingabe bis EOF (Strg+D) eingegeben wird
$cat
...
Strg+D
$cat < /etc/group Eingabe kommt aus Datei
Bsp: Umleitung stdout:
$who > userlist.log Ausgabe von who wird in Datei umgeleitet
$date +"%d.%m.%Y %H:%M" >> userlist.log Ausgabe des aktuellen Datums an userlist.log anhängen
$who >> userlist.log Ausgabe von who wird an Datei angehängt
$cat userlist.log Ausgabe der Datei auf Bildschirm
Bsp: Umleitung stderr
Das Kommado find gibt Fehlermeldungen aus, wenn Berechtigungen fehlen, diese können umgeleitet werden
$find /etc -name passwd 2> fehler.log
Bsp: Spezialfall stdout und stderr in die gleiche Datei umleiten
$find /etc -name passwd > ausgabe.log 2>&1
Bsp: Ausgaben, die nicht benötigt werden, können zu dem Spezialgerät /dev/null
umgeleitet werden (ein imaginäres schwarzes Loch)
$find /etc -name 2> /dev/null
Bsp: Erstellen einer Partition automatisieren mit fdisk
input.txt erstellen mit folgendem Inhalt:
fdisk
n
t
w
EOF
Dateiinhalt als Eingaben an fdisk umleiten
fdisk < input.txt
- Pipes und Filterprogramme Mit Pipes ist es möglich, auf einen Datenstrom nacheinander die Funktionalität mehrerer Systemprogramme (Filter) anzuwenden Die ausgabe eines Programms wird nicht auf stdout ausgegeben, sondern nach stdin des auf die Pipe folgenden Programmes umgeleitet Bsp: $ls -l /etc | more Filterprogramme: sind Programme, die von stdin (Tastatur) lesen und nach stdout (Monitor) schreiben
Nur Filterprogramme können hinter dem Pipe-Symbol verwendet werden
Beispiele für Filter:
- $cat liest von stdin und gibt Daten unverändert zeilenweise nach stdout aus
- $more
- $less
- $tee T-Stück, leitet stdin nach stdout und in Datei um
- $sort sortiert den Datenstrom
Optionen: -b führende Leerzeichen werden ignoriert -r reverse, umgekehrte Reihenfolge (absteigend) -f ignoriert Groß- und Kleinschreibung -n numerische Sortierung (Zahlen statt Ziffernfolgen) -u unique, unterdrückt mehrfache Zeilen +n sortiert nach n+1ter Spalte (n=Platzhalter für Zahl) Bsp: $who | sort +1 sortiert nach der 2. Spalte -t legt Trennzeichen zwischen Spalten fest (für Spaltensortierung) Bsp: $cat /etc/group | sort -t: +2 -n | more
- $wc word count, zählt Wörter (Standardmäßig) Zeichen oder Wörter im Datenstrom
Optionen: -l lines, nur Zeilen zählen
- $cut schneidet Spalten aus dem Datenstrom aus
Optionen: -f Liste der Spaltennummern (Standard-Trennzeichen ist Leerzeichen) Elemente der Liste werden mit Kommata getrennt -d delimiter, bestimmt das Spaltentrennzeichen Bsp: $who | cut -d " " -f1 $cat /etc/group | cut -d: -f1,3 | sort -t: +1 -n | more -c char, Zeichenbereich, Zeichenposition von links beginnend Bsp: $who | cut -c 1-3 $who | cut -f 1 -d " " | sort -u | wc -l Ausgabe der Anzahl momentan angemeldeter Benutzer:
- $grep suchbegriff filtert Zeilen nach Suchbegriff
^suchbegriff Suchbegriff muss am Anfang der Zeile stehen suchbegriff$ Suchbegriff muss am Ende der Zeile stehen Optionen: -v invertiert die Ausgabe - alle Zeilen, die NICHT den Suchbegriff enthalten Bsp: $who | grep tty1 zeigt alle Benutzer, die auf tty1 angemeldet sind $ls -l /etc | grep ^l zeigt alle Symlinks in /etc an -i ignoriert Groß- und Kleinschreibung -R rekursiv, Durchsuchen von Verzeichnissen Bsp: $cat /etc/passwd | cut -d : -f 1 | grep system Gibt es einen Benutzer "system" in der passwd $grep ^system /etc/passwd dito $cat /etc/passwd | grep bash | cut -d : -f 1 Namen alles Benutzerkonten, die die bash als Shell verw. $grep bash$ /etc/passwd | cut -d : -f1 dito
- $tr set1 [set2] translate, kann Zeichen aus Datenstrom ersetzen oder entfernen
set1 zu ersetzende Zeichen set2 die ersetzenden Zeichen, optional, standardmäßig werden Zeichen entfernt -s set1 squeeze, mehrere aufeinanderfolgende gleiche Zeichen werden auf 1 reduziert Bsp: $who | tr -s " " $who | tr -s " " | cut -d " " -f1,2 $who | tr -s " " | cut -d " " -f1,2 | tr " " "\t" tr ersetzt Leerzeichen durch Tabulator -d delete, entfernt alle Zeichen innerhalb set1 komplett aus dem Datenstrom Bsp: $who | tr -d "()" $who | tr " ()" "*[]" $who | tr "a-z" "A-Z" $who | tr [:digit:] "X"
- $tail die letzen 10 Zeilen des Datenstroms
-n die letzten n Zeilen -c n die letzten n Zeichen Bsp: $cat /etc/passwd | tail $tail /etc/passwd $who | tail -1
- $head die ersten 10 Zeichen
-n die ersten n Zeilen -c n die ersten n Zeichen Bsp: $cat /etc/passwd | head $head /etc/passwd $who | head -2 $cat /etc/passwd | head -28 | tail -1 die 28. Zeile aus der passwd Datei ausgeben $cat -n /etc/passwd | grep 28 | cut -f 2 dito
- $tee dateiname T-Stück, Umleitung in Standardausgabe UND in eine Datei
-a append, anhängen statt überschreiben
9. Zugriffsrechte auf Dateien und Verzeichnisse
- Linuxdateisysteme unterstützten die Vergabe von Berechtigungen für den Zugriff auf Dateien/Verzeichnisse - hierbei werden drei verschiedene Abstufungen unterschieden: 1. was darf Ersteller/Besitzer einer Datei/eines Verzeichnisses 2. was dürfen die Mitglieder der Gruppe, der die Datei zugeordnet ist 3. was dürfen alle anderen Benutzer - Das Rechteprinzip - $ls -l - d rwxr-xr-x 2 lxuser users 4096 16. Aug 12:39 Desktop Typ Rechtemaske Linkzähler Besitzer Gruppe Größe Datum/Uhrzeit Name
- für Berechtigungen relevant: Rechtemaske Besitzer Gruppe
Interpretation der Rechtemaske
|user |group |others
--------------------|-------------------------|-----------------------|-----------------------
Wertigkeit der Bits | 2^2 2^1 2^0 |2^2 2^1 2^0 |2^2 2^1 2^0
--------------------|-------------------------|-----------------------|-----------------------
Volle Rechtemaske | r w x |r w x |r w x
--------------------|-------------------------|-----------------------|-----------------------
Standard f. neu | r w x |r - x |r - x
zu erstellende Verz.| | |
--------------------|-------------------------|-----------------------|-----------------------
Oktal | 7 | 5 | 5
--------------------|-------------------------|-----------------------|-----------------------
Standard f. neu | r w - |r - - |r - -
zu erstellende Dat. | | |
--------------------|-------------------------|-----------------------|-----------------------
Oktal | 6 | 4 | 4
zusätzlich existiert noch eine Dreiergruppe sogenannter Spezialbits
4 | 2 | 1 | Wertigkeit
---|-----|-----|----------------------------------------------------------------
s | | | SUID-Bit (set user id), ersetzt das x des Users durch ein s
---|-----|-----|----------------------------------------------------------------
| s | | SGID-Bit (set group id), ersetzt das x von Group durch ein s
---|-----|-----|----------------------------------------------------------------
| | t | Sticky-Bit ersetzt das x von Others durch ein t
--------------------------------------------------------------------------------
SUID-Bit: wird für Programmdateien gesetzt, um das Ausführen dieser durch normale Benutzer
mit den Rechten des Besitzers zu ermöglichen (meist root)
SGID-Bit: wird für Programmdateien gesetzt, um das Ausführen dieser durch normale Benutzer
mit den Rechten der Gruppe zu ermöglichen wird für Verzeichnisse gesetzt, um alle neu erstellten Dateien und Verzeichnisse der gleichen Gruppe zuzuordnen, wie dem übergeordneten Verzeichnis
Sticky-Bit: wird für Verzeichnisse gesetzt, in denen unterschiedliche Benutzer Schreibrechte besitzen
Es bewirkt, dass jeder nur seine eigenen Dateien löschen darf
Beispiele: $ls -l /usr/bin/passwd
-rwsr-xr-x 1 root shadow 80268 3. Dez 2008 /usr/bin/passwd ---- - root=Besitzer - SUID - ermöglicht normalen Benutzern Schreibzugriff auf die Passwort-Datei (/etc/shadow) mit den Rechten von root
ls -l /usr/bin/write -rwxr-sr-x 1 root tty 9892 3. Dez 2008 /usr/bin/write --- - tty=Gruppe - SGID - ermöglicht normalen Benutzern den Zugriff auf Terminals (tty's) mit den Rechten der Gruppe tty
$ls -ld /tmp drwxrwxrwt 38 root root 4096 16. Aug 14:30 /tmp - Sticky - verhindert das Löschen fremder Dateien
Interpretation der Rechte auf Dateien und Verzeichnisse r - read, Inhalt von Dateien lesen
Inhalt von Verzeichnissen lesen
x - eXecute, Datei darf ausgeführt werden (wird z.B. vom C-Compiler automatisch gesetzt) für Binärdateien und Skripte
In Verzeichnis darf gewechselt werden
w - write, Inhalt von Dateien darf geändert werden
Inhalt von Verzeichnissen darf geändert werden
-es gibt zusätzlich noch die Möglichkeit ACLs (Access Control List) zu vergeben, je nach Distribution unterschiedlich und zu speziell & verwirrend (siehe Windows)
Setzen der Dateikreierungsmaske (umask) - die volle Rechtemaske für Verzeichnisse ist 777, für Dateien hingegen 666 - aus Sicherheitsgründen werden bei neuen Dateien/Verzeichnissen die Schreibrechte für group und others abgezogen die wird durch den umask-Wert festgelegt (0022)
Verzeichnis Dateien ----------- ------- 0777 0666 -0022 -0022 ----- ----- 755 644
- $umask zeigt aktuelle Einstellung $umask oktalwert ändert den umask-Wert - Hinweis: Änderungen mit umask wirken sich nur auf neue Dateien/Verzeichnisse aus, und gelten nur für die aktuelle Sitzung
Ändern von Besitzer und Gruppe für Dateien/Verzeichnissen
- Der Ersteller einer Datei ist automatisch der Besitzer der Datei
und dessen Standartgruppe (primäre Gruppe) die zugeordnete Gruppe
- zusätzlich zur Standardgruppe kann ein Benutzer Mitglied in weiteren Gruppen sein
- $id [username] zeigt Benutzer- und Gruppenzugehörigkeit an
- $newgrp gruppenname wechselt für die aktuelle Sitzung die Standardgruppe
Ändern von Besitzer und Gruppe für Dateien/Verzeichnissen
- $chown :gruppe dateiname Gruppe ändern
- $chown benutzer dateiname Benutzer ändern
- $chown benutzer:gruppe dateiname Benutzer und Gruppe ändern
Optionen: -R für Verzeichnisse: ändert rekursiv Besitzer/Gruppe
für alle darin enthaltenen Dateien/Unterverzeichnisse
- $chgrp gruppenname dateiname Gruppe ändern für Dateien/Verzeichnisse
- nur root darf Besitzer ändern
- normale Benutzer dürfen Gruppe ändern, wenn sie Schreibrecht an der Datei haben
und Mitglied der neuen Gruppe sind oder dass Passwort für eine Gruppe kennen (falls Gruppe Kennwort besitzt [selten])
Ändern der Zugriffsrechte für vorhandene Dateien und Verzeichnisse
- $chmod [-R] rechtemaske dateiname change modus,
- oktale Notation der Rechtemaske
$chmod 700 dir1 rwx --- ---
$chmod 2770 dir2 rwx rws --- (SGID-But gesetzt ersetzt x-Bit der Gruppe)
$chmod 5 dir3 --- --- r-x (führende Nullen muss man nicht angeben)
Symbolische Notation der Rechtemaske
wem sollen Rechte | hinzugefügt / entzogen / gesetzt werden | Welche Rechte
----------------------------|-----------------------------------------|-----------------------
u = User (Besitzer) | + - = | r w x s(SUID)
g = Group (Gruppe) | + - = | r w x s(SGID)
o = others | + - = | r w x t(Sticky)
a = all (ugo) | + - = | r w x
---------------------------------------------------------------------------------------------
Bsp: $chmod -R g+w /daten für /daten und alle darin enthaltenen Dateien/Verzeichnisse
bekommt die Gruppe zusätzlich Schreibrecht vorher: nachher: 755 rwx r-x r-x rwx rwx r-x 775 644 rw- r-- r-- rw- rw- r-- 664
Suchen von Dateien nach verschiedenen Kriterien
-$find [verzeichnis] [kriterien]
- neben dem Namen kann nach Informationen aus der Inode-Tabelle gesucht werden
- Inode-Nr
- Linkzähler
- Typ
- Größe
- Besitzer & Gruppe
- Rechtemaske
- 3 Zeitstempel
o letzter Zugriff lesend/schreibend (access time = atime) ls -lu o letzte Änderung des Inhalts (modification time = mtime) ls -l o letzte Änderung des Status (Inode) (inode change time = ctime) ls -lc
siehe man-Page zu find
10 Benutzer- und Gruppenverwaltung
- Dateien und ihre Formate
Benutzerkonten werden in der Datei /etc/passwd gespeichert (Datei gehört root und hat Standard-Rechte)
lxuser :x: 1000 : 100 : Max Muetze : /home/lxuser : /bin/bash
Login-Name :*: User-ID : Gruppen-ID : ausführlicher Name (GECOS-Feld) : home-Verzeichnis : login-Shell (falls keine dann /bin/false)
* = Platzhalter,früher wurde hier der Passwort-Hash gespeichert, heute steht dieser getrennt in /etc/shadow
Gruppenkonten werden in der Datei /etc/group gespeichert
video :x: 33 : lxuser,user1,user2
Gruppen-Name:*: Gruppen-ID : Liste der enthaltenen Benutzer
Kennwörter und Kennwortrichtlinien werden in der Datei /etc/shadow gespeichert
lxuser : $2a$10$iRGXb3GWhliAusm46D4K2uus.z/XevmNSdLaYIqpgu7T7QQNYGePO: 14831 : 0 : 99999:7 ::: Login-Name : Passwort-Hash : Änderungsdatum des PW : min. Passwort- : max. Kennwort- : Warntage vor : Kulanztage nach : Ablaufdatum (Tage seit 1.1.1970) alter in Tagen alter in Tagen Passwortablauf Ablauf des PWs (Tage seit 1.1.1970) danach kommt noch ein reserviertes Feld ^
Hinweis: Die Voreinstellungen für die Kennwortrichtlinien werden in der Datei /etc/login.defs gespeichert
- Benutzerverwaltung
Erstellen eines Benutzerkontos
- $useradd benutzername Erstellen des Benutzers "benutzername"
Optionen: -d homeverzeichnis legt Homeverzeichnis in /etc/passwd fest, Standard ist /home/benutzername -s shell Login-Shell, Standard ist /bin/bash -m erstellt automatisch das Homeverzeichnis, kopiert Inhalt von /etc/skel hinein -g gruppenname bestimmt die Hauptgruppe (Standard ist users) -G gruppenliste bestimmt Zugehörigkeit zu weiteren Gruppen (Standard ist video und dialout) -e mm/dd/yy expires, bestimmt Ablaufdatum des Kontos -c kommentar comment, für Kommentare im GECOS-Feld der passwd -f tage bestimmt Kulanztage für Anmeldung nach Ablauf des Kennwortes -p passworthash ein Passwort (bereits verschlüsselt als Hash) für das Konto -D defaults, zeigt Standardeinstellungen an bzw. ändert diese
Hinweis: Nach dem Erstellen des Benutzerkontos muss mit dem Befehl "passwd benutzer" ein Passwort vergeben werden (aktiviert)
useradd erzeugt Einträge in den Dateien /etc,passwd, /etc/group, /etc/shadow
Beispiele: $useradd -m hugo erstellt Homeverzeichnis /home/hugo, kopiert Inhalt von /etc/skel hinein
$passwd hugo
$useradd -d /srv/www/htdocs webdesigner verwendet existierendes Webverzeichnis, keine grafische Anmeldung mgl. $passwd webdesigner
$useradd -s /bin/false -d /var/lib/empty mailuser Konto ohne Homeverzeichnis und ohne Shell (/dev/null wird nicht mehr von useradd akzeptiert, deshalb /var/lib/empty) $passwd mailuser
Ändern eines Benutzerkontos
- $usermod benutzername Änderungen am Benutzerkonto vornehmen
Optionen: -l benutzername legt einen neuen Benutzernamen fest weitere Optionen wie bei useradd
Löschen eines Benutzerkontos
- $userdel benutzername Löschen eines Benutzerkontos
Optionen -r löschen des Homeverzeichnisses
- Gruppenverwaltung
Erstellen von Gruppenkonten
- $groupadd gruppenname Erstellen einer Gruppe "gruppenname"
Optionen: -r Erstellen einer Systemgruppe (GID zwischen 100 und 499)
Ändern von Gruppenkonten
- $groupmod gruppenname
Optionen: -n gruppenname legt einen neuen Gruppennamen fest -A benutzerliste fügt Benutzerkonten der Gruppe hinzu -R benutzerliste entfernt Benutzerkonten aus der Gruppe
- $groupdel gruppenname Löschen eines Gruppenkontos
- Verwalten des Status von Benutzerkonten
Der Status eines Benutzerkontos hängt vom Passwort und Einträgen in der /etc/shadow ab
- $passwd benutzername
Optionen: -S zeigt den Status an: PS -> password set (gültiges passwort gesetzt) NP -> no password (kein passwort vergeben) LK -> locked (konto gesperrt) -l lock, sperrt das Konto -u unlock, entsperrt das Konto -n tage minimales Kennwortalter -x tage maximales Kennwortalter -w tage Warntage vor Ablauf des Kontos -i tage Kulanztage vor Anmeldung nach Ablauf des Kennworts -e tage erzwingt Kennwortänderung beim nächsten Login
11 Erstellen und Einbinden von Dateisystemen
- Gerätedateien für Datenträger
IDE-Geräte unter /dev
hda -> 1. Gerät am 1. Controller
hdb -> 2. Gerät am 1. Controller
hdc -> 1. Gerät am 2. Controller
hdd -> 2. Gerät am 2. Controller
IDE-Partitionen auf HDs
hda1 -> 1. Partition auf hda
[...]
hda4 -> 4. Partition auf hda
----------------------------
hda5 -> 1. logische Partition innerhalb einer erweiterten
hda6 -> 2. logische Partition innerhalb einer erweiterten
[...]
SCSI-Geräte unter /dev
sda -> 1. Gerät
sdb -> 2. Gerät
sdc -> 3. Gerät
[...]
SCSI-Partitionen analog zu IDE
SATA-/USB-Geräte werden wie SCSI-Geräte bezeichnet
CDROM-/DVD-Lauwerke (IDE)
sr0 -> 1. Laufwerk
sr1 -> 2. Laufwerk
Diskettenlaufwerke
fd0 -> 1. Laufwerk
fd1 -> 2. Laufwerk
Hinweis: in neueren Distributionen werden IDE-Laufwerke ebenfalls wie SCSI-Laufwerke bezeichnet
- Partitionieren von Festplatten
- $fdisk gerätename wird interaktiv über Befehle bedient (Buchstaben)
Optionen: -l Partitionstabelle auflisten Befehle: m Hilfe zu den Befehlen p zeigt Partitionstabelle an n neue Partition erstellen t Typ des Dateisystem festlegen l Anzeige verfügbarer Dateisystem-/Partitionstypen d löscht Partition w Änderungen in Partitionstabelle schreiben und beenden t Änderungen verwerfen und Beenden
- Erstellen von Dateisystemen
Ein swap-System einrichten
- $mkswap gerätedatei swap-System auf !Partition! einrichten
Bsp: $mkswap /dev/sda5
- $swapon gerätedatei stellt System swap-Partition zur Verfügung (aktivieren)
- $swapoff gerätedatei deaktiviert swap-Partition
- $free zeigt Informationen zur Auslastung von RAM und swap an
Ein Linux-Dateisystem erstellen
- $mkfs gerätedatei erstellt Dateisystem auf !Partition!
-t Typ des Dateisystems, z.B. ext2, ext3 oder reiserfs Bsp: mkfs -t ext3 /dev/sda6
- Einhängen/Mounten von Dateisystemen
Um auf ein Dateisystem zugreifen zu können, muss es im Linux-Verzeichnisbaum eingehängt (gemountet) werden
Hierzu wird ein Mountpunkt benötigt (ein i.d.R. leeres Verzeichnis)
- $mount gerätedatei
Optionen: -a mounte alle Dateisysteme, die in der /etc/fstab stehen -t typ Typ des Dateisystems, wenn -t nicht angegeben, versucht mount selbstständig zu erkennen -r readonly, im Nur-Lesezugriff einhängen -w readwrite, im Schreib-/Lesezugriff einhängen -o optionen Optionsliste angeben (users, defaults, umask= etc.) Optionen: ro readonly rw readwrite (no)exec dürfen ausführbare Dateien auf Dateisystem ausgeführt werden (no)suid darf SUID-Bit ausgewertet werden (no)auto wird Dateisystem beim Systemstart automatisch eingebunden (no)user darf normaler Benutzer das Dateisystem mounten (a)sync Dateisystemzugriff synchron (gepuffert) oder asynchron
- Aushängen/Unmounten von Dateisystemen
- $umount gerätedatei (oder mountpunkt)
Hinweis: Bevor Datenträger entfernt werden, müssen sie ausgehängt werden!
- Die Datei /etc/fstab (file system table)
Hier werden Dateisysteme aufgeführt, die beim Booten des Systems automatische gemountet werden
sollen oder durch normale User bei Bedarf gemountet werden dürfen
Aufbau:
Gerätedatei Mountpunkt Dateisystem Mountoptionen Dumpwert Checkwert
/dev/sda6 /daten ext3 defaults, users 0 0
Spalte 5 Dumpwert hat nur Bedeutung für das Programm dump zur Datensicherung
Spalte 6 Checkwert legt fest, ob eine Dateisystemüberprüfung stattfindet und in welcher Reihenfolge
(0 = kein Check, 1 = zuerst, 2 = danach usw ...)
Hinweis: Partitionieren, Dateisystem erstellen, Mounten usw. kann auch bequem über YaST erledigt werden.
- Überprüfen und Reparieren von Dateisystemen
Zuprüfende Dateisysteme sollten nicht oder nur readonly gemountet sein
- $fsck gerätedatei Optionen: -t type Typ des Dateisystems -A alle aus /etc/fstab überprüfen -a automatische Reparatur ohne Rückfrage -c physische Überprüfung auf fehlerhafte Blöcke
- Anzeigen der Speicherauslastung von Dateisystemen
- $df [gerätedatei] disk free, zeigt freien Speicherplatz an Optionen: -h human readable, in einfach lesbaren Größen anzeigen (KB,MB,GB) - $du [verzeichnis] disk used, zeigt Speicherbelegung für Verzeichnis an Optionen: -h human readable, in einfach lesbaren Größen anzeigen (KB,MB,GB) -s summary, summiert anzeigen
Hinweis: Der mount-Befehl wertet die Datei /etc/fstab aus. Beim manuellen Mounten von Dateisystemen, die in der fstab aufgeführt sind, braucht nur ein Argument, entweder die Gerätebezeichnung oder Mountpunkt angegeben zu werden.
Verwendung des Texteditor "vi" - der vi steht auf sämtlichen Unix- und Linux-Systemen zur Verfügung - die Linux-Version heißt aus urheberrechtlichen Gründen "vim" - vi improved - es existiert jedoch ein Symlink vi -> vim
- $vi [dateiname] - am besten direkt dateiname öffnen, damit man sich nicht mit noch mehr kryptischen Befehlen rumärgern muss :) Optionen: -R - readonly, Datei schreibgeschützt öffnen -r - restauriert Dateien nach Systemabsturz -w zeilen - die größe eines Fensters
Es werden 3 Zustände innerhalb des vi unterschieden: - allgemeiner Befehlmodus - Texteingabemodus (Einfügemodus) - ZeilenBefehlmodus (ex-Modus)
_________ __________ i,I,a,A,o,O / \
Start vi -> |Befehl| -----------------------------> ( Einfüge- )
| modus | Esc \ modus / __________ <----------------------------- \_______/ | ^ Esc : | | oder | | Befehl v | ____________ | ex-Modus | ____________
Befehle im allgemeinen Befehlmodus
allgemeine Form: <Wiederholungsfaktor> <Befehl> <Texteinheit>
-Wechsel in den Einfügemodus
i einfügen vor dem Cursor I einfügen am Zeilenanfang a einfügen hinter dem Cursor A einfügen am Zeilenende o einfügen von neuer Zeile hinter der aktuellen O einfügen von neuer Zeile vor der aktuellen
-wichtige Befehle
dw löscht Wort ab Cursorposition 3dw löscht 3 Wörter dd löscht aktuelle Zeile 5dd löscht 5 Zeilen x löscht Zeichen ab Cursorposition 3x löscht 3 Zeichen u undo, macht letzte Befehle rückgängig (kann mehrfach betätigt werden) . Befehlwiederholung r zeichen ersetzt Zeichen an Cursorposition durch angegebenes zeichen y objekt kopiert eine texteinheit in den allgemeinen puffer yw kopiert Wort 2yw kopiert 2 Wörter yy kopiert aktuelle Zeile p fügt Pufferinhalt hinter dem Cursor ein P fügt Pufferinhalt vor dem Cursor ein
- NavigationsBefehle
h links k hoch j runter l rechts w wortweise vorwärts b wortweise rückwärts 0 zum Zeilenanfang $ zum Zeilenende G zum Textende nG zur n. Zeile /suchbegriff zur 1. Fundstelle n vorwärts suchen N rückwärts suchen
- wichtige Befehle im ex-Modus
- suchen&ersetzen :bereich s/suchtext/ersetzungstext/g Bsp: :1,$s/foo/bar/g von erster bis letzter zeile alle vorkommen von "foo" durch "bar" ersetzen
- wichtige Dateibefehle :w speichert Text in aktueller Datei :w dateiname speichern unter Dateiname :3,10w dateiname speichert Zeile 3-10 in dateiname :r dateiname fügt Inhalt von dateiname an Cursorposition ein :wq speichern & beenden :!q verwerfen & beenden
Unix/Linux für Fortgeschrittene
12 Prozessverwaltung unter Linux
- Das Linux-Prozesskonzept
Ein Prozess ist ein Programm zum Zeitpunkt der Ausführung
Jeder Prozess bekommt seinen eigenen Speicherbereich zugewiesen, dieser besteht aus:
- Codesegment -> Programmcode
- Datensegment -> globale Variablen, geöffnete Dateien z.B.
- Stacksegment -> lokale Variablen und Rücksprungadressen bei Funktionsaufrufen
- Systemsegment -> Environment (Prozessumgebung)
Prozesszustände
- aktiv -> Prozess wird von CPU verarbeitet
- bereit -> könnte die CPU nutzen, wartet auf Zuteilung
- blockiert -> wartet auf das Eintreten eines Ereignisses, ohne das der Prozess nicht fortgesetzt werden kann
Im System wird für jeden Prozess ein PCB (Process Control Block) verwaltet. Dieser enthält folgende Informationen:
- PID (Prozess-ID)
- PPID (Parent Process ID) Elternprozess
- UID \ _ Benutzer- und Gruppen-ID des Benutzers
- GID / der den Prozess gestartet hat
- Status Prozesszustand
Das Prozesssystem ist hierarchisch aufgebaut:
- init ist der Ursprungsprozess mit der PID 1, er startet weitere Prozesse
- jeder Prozess hat genau einen Elternprozess, kann aber mehrere Kindprozesse haben
Befehle zur Prozessverwaltung
- $ps listet aktuelle Prozesse auf
ohne Optionen Prozesse des aktuellen Benutzers, die einem Terminal zugeordnet sind -l Langformat, zusätzliche Informationen Spalte S zeigt den Status: D: nichtunterbrechbarer Schlaf (meist duch I/O) R: running oder runnable S: sleep (blockiert) T: trace (Prozess wurde angehalten) Z: zombie (defunct), beendet aber noch in Prozessliste -a alle Prozesse, die einem Terminal zugeordnet sind außer "session leaders" -e | -A alle Prozesse -u benutzername die Prozesse eines Benutzers -t terminal die Prozesse eines Terminals BSD-Optionen a alle Prozesse, die einem Terminal zugeordnet sind außer "session leaders" x alle Prozesse ohne Terminal
- in KDE kann mit Strg+Esc die Systemüberwachung aufgerufen werden, die auch alle Prozesse anzeigt
- $pstree zeigt hierarchischen Prozessbaum auf
-p z
- $top interaktives Programm, listet Prozesse nach CPU-Nutzung sortiert auf
interaktive Befehle h Hilfe k kill, beendet Prozess nach angabe der PID r renice, ändern des Nice-wertes (Priorität) q beendet top
Befehle zum Senden von Signalen
- $kill pid sendet ein Signal an einen Prozess
-SIGTERM | -15 Standardsignal, wenn kein Signal angegeben wird, zum Beenden (terminieren) eines Prozesses -SIGKILL | -9 kill-Signal zum sofortigen Beenden eines Prozesses (harte Methode)
- $killall prozessname sendet ein Signal an alle Prozesse mit dem Namen Hinweis: Übersicht über signale liefert man 7 signal
Beenden von Prozessen auch mit top möglich Sämtliche Prozesse werden im virtuellen Dateisystem /proc abgebildet Pro Prozess existiert ein Unterverzeichnis mit der PID als Name viele Systemdienste hinterlegen ihre PID in einer Datei mit der Dateinamenserweiterung .pid im Verzeichnis /var/run
Befehle zum ändern der Prozesspiorität
Zusätzlich zur Standardpriorität wird ein sogenannter Nice-Wert verwaltet Dieser dient in erster Linie
zum vermindern der Priorität von Benutzerprogrammen, kann aber durch root auch zum erhöhen verwendet werden
Prioritätswerte: 1 (niedrigste) bis 20 (höchste)
Nice-Werte: positive Werte vermindern die Priorität, negative Werte (nur root) erhöhen die Priorität
-20 höchste Priorität ... 0 ... 19 niedrigste Priorität
- $nice programm startet ein Programm mit verminderter Priorität
- $renice nicewert pid ändert den nice-Wert für einen laufenden Prozess
Vorder- und Hintergrundverarbeitung auf der Shell
Um nach dem Start eines Programms auf der Shell weiterzuarbeiten, ohne auf die Beendigung warten zu müssen,
kann man das Programm im Hintergrund ausführen lassen.
Programm im Hintergrund starten:
- $programm &
Bsp: $sleep 60 & sleep als Hintergrund-job starten [1] 8448 Job-ID PID
Vordergrundprogramme in den Hintergrund bringen
Strg + z stoppt das Programm, der Shellprompt erscheint, das Programm bekommt eine Hintergrund-Job-ID
- $bg (job-id) background, setzt Programm im Hintergrund fort
Hintergrundprogramme in den Vordergrund bringen
- $fg (job-id) foreground, setzt Programm aus dem Hintergrund im Vordergrund fort
Alle Hintergrund-Jobs anzeigen
- $jobs zeigt alle Jobs an
Zeitgesteuerte Ausführung von Programmen
Einmalige Ausführung mittels AT-Dienst
- Prüfen bzw. Starten des Dienstes atd (nur root)
- $rcatd status ob Dienst läuft
$rcatd start Dienst starten $insserv atd Dienst wird beim nächsten Booten automatisch gestartet
AT-Jobs verwalten
- $at datum/uhrzeit erstellt einen AT-Job, erwartet eingaben von stdin
at> befehl1 [Enter] at> befehl2 [Enter] at> Strg+D mit EOF abschließen
Bsp:$at 14:30 14:30 halt
$at 17:00 08/25/10 um 17:00 am 25.08.2010 $at now + 10 minutes in 10 Minuten
$atq AT-Queue, zeigt Warteschlange an Job-Nr Datum/Zeit Benutzer $atrm job-nummer löscht einen AT-Job
Hinweis: Die AT-Jobs werden bis zu ihrer Ausführung als Dateien im Verzeichnis /var/spool/atjobs gespeichert Es ist möglich bestimmten Benutzern die Verwendung von at zu erlauben oder zu verbieten, standardmäßig ist es für jeden erlaubt. Konfiguriert wird dies in den Dateien /etc/at.allow bzw. /etc/at.deny Da dem AT-Dienst kein Terminal zugeordnet ist, werden Ausgaben nach stdout u. stderr dem Benutzer des AT-Jobs per Mail zugestellt /var/spool/mail/benutzername
Periodisch zeitgesteuerte Jobs mit cron
Voraussetzung: Der cron-Dienst muss laufen
- $rccron status
Die Verwaltung der Jobs erfolgt mittels der Datei crontab
- es exisitiert eine crontab für das System (/etc/crontab)
- jeder Benutzer hat die Möglichkeit eine eigene crontab zu verwalten
-$crontab
-l zeigt die crontab an -e startet den "vi" zum Editieren der crontab -u benutzername die crontab eines anderen Benutzers verwalten
Aufbau einer Benutzer-crontab:
-$man 5 crontab
# minuten stunden monatstag monat wochentag befehl
0 8,15 * * 1-5 myscript Mo - Fr um 8:00 und 15:00 0,30 * * * * myscript2 zu jeder vollen und halben stunde * * * * * myscript3 im Minutentakt (kleinste Einheit) */5 * * * * myscript4 aller 5 Minuten 0 1-23/2 * * * myscript5 jede zweite stunde von 1-23uhr 0 16 24 12 * myscript6 immer am 24.12. um 16:00
Hinweis: Die ersten 4 Spalten sind UND-verknüpft
die Argumente in den Spalten, falls mehrere vorhanden sind, sind ODER-verknüpft
die crontab des Systems /etc/crontab enthält eine zusätzliche Spalte für ein Benutzerkonto vor der Befehlespalte
Für Wartungsarbeiten im System, die zu keinem bestimmten Zeitpunkt aber in regelmäßigen Intervallen ausgeführt werden
sollen, gibt es vorgefertigte Verzeichnisse für stündliche, tägliche, wöchentliche und monatliche Abarbeitung
(/etc/cron.hourly,/etc/cron.daily,/etc/cron.weekly,/etc/cron.monthly) in die root ein entspr. Skript legen kann
Wochentage: 0 sonntag
1 montag 2 dienstag 3 mittwoch 4 donnerstag 5 freitag 6 samstag 7 sonntag
13 Installation eines OpenSuse Linux 11.1
Vorüberlegungen
-welche Distribution
-eventuell Live-System zum testen Hardwareerkennung/-anforderungen
-ist Linux einziges System od. soll Dualboot eingerichtet werden
-welchen Bootmanager wo installieren (MBR oder Bootsektor)
-welche Partitionierung benötigt wird
-in welchem Umfang soll Linux installiert werden (mit grafischer Oberfläche oder nur Konsolen)
-in welchem Umfang sind zuvor Daten zu sichern z.B. MBR sichern
Sichern des Master Boot Record und Bootsektor vor der Partitionierung (wenn bereits anderes Betriebssystem vorhanden)
-während der Installation mit Strg+Alt+F2 auf 2.Konsole wechseln
-Sicherungsmedium mounten mittels mount /dev/sdb1 /mnt
-Sicherung der Sektoren mit dem Befehle dd (MBR)
dd if=/dev/sda of=/mnt/windows.mbr bs=512 count=1
Input File Output File Blockgröße Anzahl
Sicherung der Sektoren mit dem Befehle dd (Bootsektor)
dd if=/dev/sda1 of=/mnt/windows.bs bs=512 count=1
Zum zurücksichern von MBR und BS erfolgt analog, wobei if und of getauscht werden.
Konfiguration des X-Server mit sax2
Das Programm sax2 ermöglicht die Konfiguration der Hardware des X-Servers
(I/O-Schnittstellen: Grafikkarte, Monitor, Tastatur, Maus)
-Wechsel in runlevel 3 (ohne grafisches System)
-#init 3
-#sax2 (Hinweis: sax2 kann NICHT den verwendeten Grafiktreiber ändern, nur Auflösung und Monitorgröße)
-Zurück wechseln in runlevel 5
-#init5
Hinweis: Die Konfigurationsdatei des X-Server ist /etx/X11/xorg.conf
Sax2 erstellt beim Laden dieser Datei immer eine Sicherungskopie /etc/X11/xorg.conf.saxsave
14 Softwareinstallation und Paketverwaltung
Software kann in folgenden Formen bereitgestellt werden
- als Tarball (komprimierte Archive, enthalten meist Quellcode, Endung *.tar.gz, *.tgz, *.tar.bz2)
- als RPM-Pakete (Redhat Package Manager)
Aufbau einer RPM-Datei: abc-2.0.7-1.i586.rpm
Paketname: abc Version: 2.0.7 RPM-Version: 1 (Release) Architektur: i586 (Intel-kompatible 32bit-Systeme) x86_64 (Intel-kompatible 64bit-Systeme)
Enthält: Informationen zu Paketabhängigkeiten
Kurzbeschreibung der Software Sämtliche Dateien mit Installationspfad u.a. (md5sum, PGP-Signatur usw.)
Installierte Pakete werden in einer Datenbank verwaltet unter /var/lib/rpm
Paketverwaltung mit yast
Kategorie Software -> Repositories (Software-Quellen/Paket-Quellen): DVD, Online-Quellen, Netzwerkfreigaben -> Software installieren/löschen (Softwaremanagement) -> Filter (Suchen, Paketgruppen u.a.) -> Abhängigkeiten werden automatisch aufgelöst -> eventuelle Konflikte müssen manuell gelöst werden (Vorschlag auswählen)
Paketverwaltung mit rpm auf der Konsole
-$rpm [dateiname] [dateiname2] ... -i | --install installieren -U | --update Update/Installation -e | --erase Deinstallation --oldpackage Downgrade eines installierten Paketes auf eine ältere Version
Bsp: Finden eines Paketes und Installation in einem Befehl
-$find /pfad -name "dateiname*" -exec rpm -i {} \; ^ Platzhalter für gefundene Datei(en) ^ Ende der Argumente (eigtl. nur ; da ; Metazeichen muss escaped werden mit \)
Abfragen von Paketinformationen
-$rpm -q paketname fragt Informationen zu installierten Paketen ab -qa listet alle installierten Pakete auf, sinnvollerweise mit | grep zu kombinieren -qi paketname listet Kurzinformationen (RPM-Header) zu einem Paket auf -ql paketname listet alle Dateien des Paketes auf -qlv ^ zusätzlich noch Informationen wie ls -l -qc zeigt Konfigurationsdateien an -qf dateiname zeigt an, zu welchem Paket die Datei gehört -$rpm -qp rpm-datei fragt Informationen über RPM-Datei ab
Verwenden von Tarballs
Obwohl RPM-Pakete die bevorzugte Installationsmethode sind, kann es vorkommen, dass bestimmte Programme oder Treiber nicht als RPM-Pakete, sondern nur als Tarballs vorliegen. Hierbei wurden 2 Funktionen hintereinander auf die Software angewandt: - alle Dateien wurden in ein Archiv zusammengefasst (unkomprimiert von tar = tape archiver) - Komprimierung der Archivdatei (.tgz/.gz = GNU Zip | .bz2 = BZip2)
Entpacken von Tarballs
-$tar Tape Archiver -x extract, extrahieren -c create, Archiv erzeugen -t test, listet Inhalt des Archivs auf -f dateiname filename, Dateiname -j | --bzip2 Archiv durch bzip2 filtern (nur beim komprimieren benötigt) -z | --gzip Archiv durch bzip2 filtern (nur beim komprimieren benötigt)
Hinweis: tar kann selbst nicht komrimieren/dekomprimieren durch Angabe der entsprechenden Option ruft tar implizit ein Komprimier-Programm auf (s.o.) um die abschließende Installation der Software durchzuführen muss die im Archiv enthaltene Readme-Datei gelesen werden (Installations-Anleitung)
Erstellen von Tarballs
-$tar -cjf archivname.tar.bz2 datei-/verzeichnisname
Komprimierprogramme
-$gzip dateiname GNU Zip-Programm, erstellt komprimierte Versionen der Dateien mit der Erweiterung .gz -c belässt Dateien unverändert, gibt die komprimierten Daten auf stdout aus -r rekursiv für Verzeichnisse -d dekomprimieren -> gunzip -wert Komprimierungsfaktor 1 -> niedrig ... 6 -> Standard ... 9 -> max. Komprimierung -$bzip2 erstellt komprimierte Versionen der Dateien mit der Erweiterung .bz2 -k keep, erhält ursprüngliche Datei restliche Optionen analog zu gzip
Tastenkombination zum Midnight Commander
Tab wechselt zwischen Fenstern
Enter führt Programme/Skripte aus, wechselt Verzeichnisse oder betrachtet Dateien
Strg+s Datei suchen (Anfangsbuchstaben) im aktuellen Verzeichnis
Strg+o Hauptfenster ausblenden, Shell anzeigen
Einfg zum Markieren oder Demarkieren einzelner Dateien
F5 kopiert markiertes F6 verschiebt markiertes / benennt um F8 löscht markiertes
F3 Datei anzeigen
F4 Datei editieren
F7 Verzeichnis anlegen
Alt+Enter übernimmt Dateinamen der markierten Datei in die Befehlezeile
15 Der Linux-Systemstart
Der Bootloader GRUB
- ein Teil von GRUB wird im MBR oder einem Bootsektor installiert (stage1)
- die übrigen Teile von GRUB befinden sich im Dateisystem /boot/grub (stage1.5, stage2)
und werden von stage1 nachgeladen
- das Bootmenü befindet sich in der Datei /boot/grub/menu.lst
Aufbau der /boot/grub/menu.lst
-globaler Bereich:
default 0 -> wenn keine Auswahl, wird erster Menüeintrag gestartet timeout 8 -> Zeitdauer der Menüanzeige in Sekunden
-Abschnitte werden mit title "anzuzeigender Menüeintrag" eingeleitet
root (hd0,2) -> bestimmt die Partition, auf die sich nachfolgende Anweisungen beziehen (hd0,0) -> 1.HD, 1.Partition (hd0,2) -> 1.HD, 3.Partition kernel /boot/vmlinux kerneloptionen - der zu startende Kernel mit Kerneloptionen initrd /boot/initrd - die zu ladende initial ramdisk (minimales Dateisystem, wird in RAM geladen enthält die wichtigsten Treibermodule und Systemtools, die der Kernel benötigt, um das /-Dateisystem einzuhängen)
-interaktiver Befehlsmodus von GRUB
wenn Bootmenü erscheint
Esc grafisches Menü verlassen
e ausgewählten Eintrag editieren
c wechselt in Befehlsmodus (Prompt: grub> )
Bsp: manuelles Booten im Befehlsmodus (falls menu.lst defekt o.ä.) grub> root (hd0,4) Dateisystemtyp sollte angezeigt werden, bspw: grub> kernel /boot/vmlinuz root=/dev/sda6 grub> initrd /boot/initrd grub> boot
Hinweis: im grafischen Bootmenü können zusätzliche Optionen eingetragen werden, die an den Kernel übergeben werden
im textbasierten Menü mittels e die Menüzeile u. Kerneloptionen ergänzen
Bsp: 1 | init=1 -> Runlevel 1 (Anmeldung nur für root, kein Multiuser [sog. FailSafe-Modus]) init=/bin/sh -> startet anstelle des Init-Programms eine root-Shell ohne Anmeldung (zum Passwort ändern o.ä.)
Schutz vor Änderungen im Bootmenü von GRUB bietet die Vergabe eines Passwortes in der Datei /boot/grub/menu.lst als MD5-Hash
Bsp: #grub > /grubmd5.txt grub> md5crypt erzeugen eines Password-Hashs password: Montag,13 eingeben des Passwortes encrypted: $hash... angezeigten Hash notieren/kopieren #vi /grubmd5.txt alles bis auf encrypted: $hash... löschen #vi /boot/grub/menu.lst default 0 timeout 8 :r /grubmd5.txt verschlüsselten Hash einfügen, wie in nächster Zeile anpassen password --md5 $hash...
Zum Sichern des Bootens eines Menüeintrages durch Passworteingabe muss am Ende der title-Zeile
lock angehängt werden
SysV-Init / Der Init-V-Prozess (ursprüngliches Unix hieß System V)
typische Prozesse beim Systemstart - der Bootloader lädt den Kernel (Prozess 0) - der Kernel startet das Programm /sbin/init (Prozess 1) ° init wertet die Datei /etc/inittab aus ° initialisiert das System durch Aufruf der Skripte /etc/init.d/boot* ° ruft das Skript /etc/init.d/rc mit der Nummer des Standardrunlevels als Argument auf - das Skript /etc/init.d/rc startet weitere Skripte in dem Verzeichnis /etc/init.d/rc?.d/ (? = Nummer des Runlevel-Arguments) - Erreichen des Standardrunlevels -> Anmeldung ist möglich
Runlevel - Zustände, in denen das System mit unterschiedlicher Funktionalität betrieben werden kann (0-6 bzw. S) 0 -> Shutdown mit Halt/PowerOff 1 (S)-> SingleUser Mode, nur root-Login, auch FailSafe (abgesichert) genannt von neuen Distributionen 2 -> MultiUser Mode, mehrere (lokale) Benutzer aber ohne Netzwerk 3 -> MultiUser Mode, mehrere Benutzer mit Netzwerk 4 -> ungenutzt/reserviert 5 -> MultiUser Mode, mehrere Benutzer mit Netzwerk und X (grafischer Server) 6 -> Shutdown mit Reboot Der Standard-Runlevel wird in der /etc/inittab festgelegt (meist 5)
Aufbau der /etc/inittab id:runlevel:action:befehl -id -> eindeutige Zeichenkette -runlevel -> Nummer(n) der Runlevel -action -> wichtige Schlüsselwörter: initdefault -> Standardrunlevel bootwait -> nachfolgendes Befehle während des Bootvorgangs ausführen, auf Beendigung warten wait -> nachfolgendes Befehle ausführen, auf Beendigung warten respawn -> nachfolgendes Befehle ausführen, nach Beendigung sofort nochmal ausführen ctrlaltdel -> nachfolgendes Befehle ausführen, wenn Strg+Alt+Entf gedrückt wird sysinit -> Befehle wird nur einmal beim Booten ausgeführt once -> Befehle wird einmal bei jedem Runlevelwechsel ausgeführt
Wechsel der Runlevel $init runlevelnummer oder $telinit runlevelnummer
$runlevel zeigt vorherigen u. aktuellen Runlevel
Die Runlevel-Scripte (rc-Skripte bzw. Start-/Stop-Skripte) - abhängig von der Nummer des Runlevels (n) werden die Skripte im Verzeichnis /etc/init.d/rc(n).d (symbolische Links auf das eigentliche rc-Skript im übergeordneten Verzeichnis /etc/init.d) - die Skripte, die mit Sxy... beginnen, werden beim Eintritt in den Runlevel mit dem Argument 'start' aufgerufen - Symlinks mit niedrigeren Zahlen werden vor Skripten mit höheren Zahlen ausgeführt - hierdurch werden die im Runlevel benötigten Dienste gestartet - die Symlinks, die mit Kxy... beginnen, werden beim Verlassen des Runlevels mit dem Argument 'stop' aufgerufen - Symlinks mit niedrigeren Zahlen werden vor Skripten mit höheren Zahlen ausgeführt - hierdurch werden die im Runlevel benötigten Dienste gestoppt - die Symlinks in den Runlevelverzeichnissen werden für das automatische Starten/Beenden von Diensten verwendet - mit dem Befehl $insserv skriptname werden die Symlinks in den Runlevelverzeichnissen erzeugt (Suse-spezifisch) - $insserv -r skriptname entfernt die Symlinks für das automatische Starten
Manuelles Starten/Beenden von Diensten - Aufruf der rc-Skripte mit entsprechendem Argument (start|stop|restart|status|...) Variante 1: #/etc/init.d/skript (start|stop|restart|status|...) Bsp: #/etc/init.d/atd start Variante 2: #/etc/rc.d/skript (start|stop|restart|status|...) Bsp: #/etc/rc.d/atd start Um die Skripte ohne Pfadangabe nutzen zu können, wird i.d.R. ein weiterer Symlink mit dem Präfix rc im Verzeichnis /usr/sbin erstellt (Suse-spezifisch) Variante 3: #rcskript (start|stop|restart|status|...) Bsp: #rcatd start Variante 4: #service skript (start|stop|restart|status|...) Bsp: #service atd start
Hinweis: Für das Erstellen eigener Start-/Stop-Skripte dient die Vorlage /etc/init.d/skeleton Im Yast (Kategorie System) steht der Runlevel-Editor zur Verfügung. Er legt fest welche Dienste automatischt gestartet werden
16 Drucken unter Linux Druck- oder Spooling-Systeme - Drucker werden über Druckwarteschlangen angesprochen (print-queues) - Druckaufträge werden in der Queue gespoolt (in Warteschlange eingereiht) und nacheinander an den Drucker gesendet - Oft liegen die Daten nicht in der Sprache des Druckers vor und werden beim Verlassen der Queue über einen Filter (=Druckertreiber) zum Drucker gesendet. Der Filter wandelt die Daten in die Druckersprache um (PostScript, PCL [Printer Common Language] u.a.) - folgende Spooling-Systeme können unter Linux eingesetzt werden - (BSD)-LPD (Line Printer Daemon) Urvater vieler Spoolssysteme, der in BSD-Unix verwendet wurde Drucker werden in Datei /etc/printcap verwaltet für jeden Drucker wird unter /var/spool eine (oder mehrere) Queue (Warteschlange) als Verzeichnis erstellt für unterschiedliche Druckformate unterschiedliche Warteschlangen, z.B. raw, ascii, color usw. der Dienst heißt lpd und wird über /etc/init.d/lpd start|stop|restart ... verwaltet - LPRng (Line PrinteR next generation Weiterentwicklung des BSD LPD - CUPS (Common Unix Printing System) ist ein völlig neu entwickeltes Spooling-System pro Drucker wird nur eine Warteschlange benötigt komplexe Filtersysteme ermöglichen die Umwandlungder Daten in die Druckersprache unterstützt eine Vielzahl von Druckern der Dienst heißt cupsd und wird über das Start-/Stop-Skript /etc/init.d/cups verwaltet - Drucker unter cups mittels yast installieren prüfen ob folgende Softwarepakete installiert sind: -cups -cups-client -cups-drivers -cups-libs -manufacturer-PPDs Yast -> Hardware -> Drucker - Verbindung auswählen (Anschluss des Druckers) - Filter/Treiber (PPD) auswählen - sinnvollen Namen für Druckerwarteschlange vergeben Verwaltung der Druckaufträge unter KDE K-Menü -> Dienstprogramme -> Drucken -> Drucken / Druckerverwaltung (system-config-printer) / kjobviewer Verwalten der Drucker auf der Konsole $lpr -P queuename datei druckt Datei in die Warteschlange queuename $lpq -P queuename zeigt Druckaufträge in der Warteschlange $lprm -P queuenane jobnr löscht Druckauftrag mit jobnr aus Warteschlange - löscht alle Druckaufträge in Warteschlange $lpc line printer control, interaktive Befehle lpc> status status der Warteschlangen anzeigen Hinweis: die oben aufgeführten Befehle stammen vom BSD-LPD-Drucksystem
Spezielle CUPS-Tools #cupsenable queuename Drucker aktivieren, Warteschlange bleibt erhalten #cupsdisable queuename Drucker deaktivieren, Warteschlange bleibt erhalten #accept queuename aktiviert Warteschlange #reject queuename deaktiviert Warteschlange Verwendung des Tools lpadmin zum Instalieren und Löschen von Druckern PPD-Datei muss vorhanden und bekannt sein, CUPS sucht diese unter /usr/share/cups/model $lpadmin -p queuename -E -v parallel:/dev/lp0 -m DEC/LJ250-lj250.ppd.gz ^ aktiviert Drucker ^ Geräteschnittstelle (device-uri) socket://IP:9100 (TCP Standardport LPD) ^ PPD-Name $lpadmin -x lj250 löscht den Drucker
Hinweis: Die Drucker werden in der Datei /etc/cups/printers.conf Die Druckjobs werden unter /var/spool/cups abgelegt/verwaltet
Verwaltung von Druckern über das CUPS-Web-Frontend CUPS bringt einen eigenen Webserver mit, der auf localhost TCP-Port 631 läuft http://localhost:631 | http://127.0.0.1:631 die Konfiguration des Webservers erfolgt über die Datei /etc/cups/cupsd.conf
17 Kernel und Kernelmodule kompilieren
Ein zusätzliches Kernelmodul kompilieren - der monolithische Kernel vmlinuz wird zur Laufzeit durch Kernelmodule ergänzt (Module werden i.d.R. automatisch geladen) - die Kernelmodule müssen zur Kernelversion passen, sie befinden sich unterhalb von /lib/modules/$(uname -r) $uname -r zeigt Version des aktuell gestarteten Kernels an - Linux-Distributionen haben oft angepasste Kernel, die vom Original (Vanilla-Kernel, Plain-Jane-Kernel) abweichen - Vanilla-Kernel: www.kernel.org - OpenSuse: download.opensuse.org - Hersteller von Hardware-Komponenten stellen oftmals die Gerätetreiber als Quellcode für ein Kernelmodul als Tarball zur Verfügung - Voraussetzung zum Kompilieren sind folgende Pakete: kernel-sources (passend zur Version des aktuellen Kernels) gcc (GNU C-Compiler) gcc-c++ (GNU C++-Compiler) make (verarbeiten von Makefiles, Teil der autotools [automake])
Befehles zur Modulverwaltung $lsmod zeigt eine Liste der geladenen Module Bsp.: $lsmod |grep e1000 $modinfo modulname zeigt Informationen zu einem Modul an Bsp.: $modinfo e1000 | more $modprobe modulname lädt das Modul u. evtl. benötigte Module Bsp.: $modprobe e1000 $rmmod modulname entfernt das Modul aus dem Speicher Bsp.: $rmmod e1000 $lsmod | grep e1000 Hinweis: Normalerweise werden Module vom Kernel automatisch geladen, zusätzlich werden die Dateien /lib/modules/versionsnr/modules.dep -> Modulabhängigkeiten /etc/modprobe.conf -> Zuordnung von Gerätenname zu Modulen
Kernel Konfigurieren und Kompilieren - Kernelquellen und Kompiler müssen installiert sein - Das Konfigurieren der Kernelfunktionen erfolgt in der Datei /usr/src/linux/.config mit mehr als 1000 Funktionen, für die man wählt: yes - in den Kernel kompilieren module - als Kernelmodul kompilieren no - nicht kompilieren - als Ausgangsbasis soll die .config des aktuellen Kernel dienen $cd /usr/src/linux $make cloneconfig erzeugt .config (oder aus /proc/config.gz entpacken oder aus /boot/config-$(uname -r) kopieren)
Bearbeiten der Kernel-Konfiguration mittels Konfigurationstool $make xconfig KDE-Version, QT-Bibliothek (braucht qt3-devel-Bibliotheken) $make gconfig GNOME-Version, GTK-Bibliothek (braucht gtk2-devel-Bibliotheken u.a.) $make menuconfig Textbasiert, NCURSES-Bibliothek (braucht ncurses-devel-Bibliothek)
Kompilieren des Kernels und der Module $make clean löscht alte Objektdateien $make bzImage kompiliert nur den Kernel (vmlinuz) -> /usr/src/linuxarch/x86/boot/bzImage $make modules erzeugt die Kernelmodule (wenn etwa nur an Modulauswahl etwas geändert wurde) oder $make all alles oben aufgeführte
Installieren des Kernels und der Module
$mv /usr/src/linuxarch/x86/boot/bzImage /boot/vmlinuz-neu - im Bootmenü von GRUB neuen Eintrag zum booten des neuen Kernels hinzufügen - evtl. initrd erzeugen und installieren nach /boot/initrd-neu - oder automatisch (je nach Distribution) $make modules_install installiert Module nach /lib/modules/$(uname -r) $make install installiert Kernel nach /boot, erzeugt evtl. initrd, Bootloader-Einträge u.a.
Manuelles Installieren /usr/src/linux/arch/x86/boot/bzImage kopieren nach /boot/vmlinuz-version /usr/src/linux/System.map kopieren nach /boot/System.map-version $make modules_install oder manuell alle Module (.ko*) kopieren nach /lib/modules/version evtl. /boot/grub/Device.map anpassen $mkinitrd -k vmlinuz-version -i initrd-version -M /boot/System.map-version Bootloader-Einträge hinzufügen in /boot/grub/menu.lst nach Schema: title Angezeigter_Name_im_Bootloader root (hd0,1) kernel /boot/vmlinuz-version root=/dev/sda2 evtl. noch weitere Optionen wie resume=, vga=, splash=, initrd /boot/initrd-version
18 Grundlagen der Shellprogrammierung -Login-Skripte Systemweite Skripte Folgende Dateien werden von der Shell bei der Anmeldung jedes Benutzers ausgeführt: /etc/profile wird einmalig beim Login ausgeführt, enthält z.B. die Einstellun der umask 022 /etc/profile.local ist anzulegen für eigene Einstellungen, ergänzt /etc/profile /etc/bash.bashrc wird beim Starten einer Bash-Shell abgearbeitet (auch bei Subshells) enthält shellspezifische Einstellungen, z.B. Aliase /etc/bash.bashrc.local ist anzulegen für eigene Einstellungen, ergänzt /etc/bash.bashrc
-Benutzerspezifische Skripte befinden sich im /home-Verzeichnis jedes Benutzers und werden nach den systemweiten abgearbeitet ~/.profile wird einmalig nach dem Login dieses Benutzers abgearbeitet ~/.bashrc wird beim Starten jeder Bash-Shell durch diesen Benutzer abgearbeitet
Hinweis: Die Datei /etc/issue legt die Beschriftung der Login-Textkonsolen (tty) fest Nach der Anmeldung mit einer Login-Shell wird der Text aus der Datei /etc/motd angezeigt (Message of the Day)
Aliase Ein Alias ist ein alternativer Name für einen Befehleaufruf. Er ermöglicht einen komplexen Befehleaufruf zu vereinfachen. $alias name='komplexer Befehl' erstellt einen Alias für die aktuelle Shell $alias zeigt alle gesetzten Aliase an $unalias löschen eines Alias Um Aliase für sämtliche Shells zu definieren, können die Befehle in die Datei /etc/bash.bashrc.local (für alle User) oder in die ~/.bashrc oder ~./alias eingetragen werden
Metazeichen
; trennt Befehle auf einer Zeile, werden hintereinander abgearbeitet befehl & startet befehl im Hintergrund befehl1 && befehl2 befehl2 wird nur ausgeführt, wenn befehl1 erfolgreich war (ohne Fehler -> exit-status 0) befehl1 || befehl2 befehl2 wird nur ausgeführt, wenn befehl1 nicht erfolgreich war (exit-status !=0) $[...] arithmetische Berechnung Bsp: echo $[5+2] $(befehl) oder `befehl` Kommandosubstitution, Ergebnis des Befehls wird in die Befehlszeile übernommen Bsp: es sind $(who | wc -l) benutzersitzungen aktiv (befehl1 ; befehl2) beide Befehle werden in der gleichen Subshell ausgeführt Bsp: (ls -la ; date) > inhalt.dir {...} bildet Zeichnekettenkombinationen mit den Ausdrücken innerhalb der Klammern .. zwischen Argumenten in Klammern heißt bis {1..9} = von 1 bis 9 , zwischen Argumenten in Klammern kennzeichnet Auflistungen Bsp: echo file.{conf,log} echo file{1..5}.{conf,log}
Shellvariablen Die Shell ermöglicht Werte in Variablen zu speichern, um später auf diese Werte zurückzugreifen Es existieren eine Reihe vordefinierte (Umgebungsvariablen), es können auch eigene Varaiblen definiert werden
Lokale Variablen - gelten nur in der aktuellen Shell var1=wert1 Legt Variable var1 an mit wert1 als Wert declare var2=wert2 Legt Variable var2 an mit wert2 als Wert let var3=wert3 Legt Variable var3 an mit wert3 als Wert Hinweis: let wird zum zuweisen eines arithmetischen Wertes zu einer Variable benutzt, Bsp: let var4=5+4
Globale Variablen - gelten auch in später gestarteten Subshells Sie werden durch Exportieren von lokalen Variablen erzeugt var1=wert1 export var1 export var2=wert2 declare -x var3=wert3 $export || $env zeigt alle globalen Variablen $env -i mit leerer Umgebung (keine Umgebungsvariablen) starten $set zeigt alle lokalen und globalen Variablen sowie Funktionen an $unset variablenname löscht eine Variable Hinweis: Änderungen an globalen Variablen haben keinen Einfluss auf Eltern-Shells (die Subshell erhält eine Kopie der Variablen der Eltern-Shell) Systemweite Varaiblendefinitionen erfolgen in der Datei /etc/profile bzw. /etc/profile.local bzw. ~/.profile auf Benutzername
Wichtige globale Systemvariablen
BASH Pfad der Bash-Shell BASH_VERSION Version der Bash HOME Homeverzeichnis des Benutzers LOGNAME Anmeldename des aktuellen Benutzers MAIL Pfad zur Mailboxdatei des aktuellen Benutzers OLDPWD vorheriges Arbeitsverzeichnis PWD aktuelles Verzeichnis PATH Suchpfade für Programmdateien PS1 Primärer Prompt der Shell PS2 Sekundärer Prompt der Shell
Steuerzeichen für PS1 \t Zeit \d Datum \s Name der Shell \w aktuelles Verzeichnis mit Pfad \W aktuelles Verzeichnis ohne Pfad \u Benutzername \h Hostname \\$ # für root sonst $ \\ Backslash
Standard OpenSuse: PS1="\u:\W \\$ "
Automatische Variablen ihr Einsatz ist oft nur in skripten sinnvoll
$0 ..... $9 enthalten die Parameter des Skriptaufrufes Bsp: $./myscript arg1 arg2 $0 $1 $2 $# enthält die Anzahl der Argumente $? enthält den exit-Status des letzten Befehlaufrufs (0 = erfolgreich, kein Fehler) $$ enthält die PId der aktuellen shell $@ enthält alle Argumente des Skriptaufrufes als einzelne Strings $* enthält alle Argumente des Skriptaufrufes als ein String
Erstellen von shellscripten Eine textdatei, die mit der Zeile
#! /bin/bash
beginnt, auch genannt "shebang". Sie legt den zur Abarbeitung des Skriptes erforderlichen Interpreter fest (die Shell /bin/bash im Beispiel) Kommentare im Skript beginnen mit # Zur Ausführung eines Skripts ist das Recht x (ausführen) für die Datei erforderlich
Bsp: $mkdir scripts; cd scripts $mcedit myscript #! /bin/bash echo Name des Scripts: $0 echo Argument1: $1 echo Argument2: $2 echo anzahl der Argumente: $# #Ende des Scripts $chmod a+x myscript $./myscript hallo welt
In interaktiven Skripten können Benutzereingaben mit dem Kommando: read variable in einer Variablen gespeichert werden
Bsp: ein script userid soll nach einem Benutzernamen fragen und dazu die entsprechende User-ID ausgeben cd scripts $mcedit myscript #! /bin/bash echo -n "Alta sag mir deinen Namen und ich sag dir wer du bist: " read user_name userid=$(grep $user_name /etc/passwd | cut -d: -f3) echo $user_name hat die UID $userid. $chmod a+x userid $./userid
Anweisungen für Verzweigungen
Die if - Anweisung
if ifbefehl1 then thenbefehlsliste1 [elif ifbefehl2 then thenbefehlsliste2] ... [else elsebefehlsliste] fi Hinweis: Wenn der exit-Code des ifbefehls 0 ist (Befehl erfolgreich, keine Fehler), wird der then-Zweig durchlaufen der Befehl test [optionen] wird häufig als ifbefehl zum Prüfen
Bsp: $cd scripts $mcedit fileexist #! /bin/bash if test -e $1 then echo Datei existiert else echo Datei nicht gefunden fi $chmod a+x fileexist $./fileexist /etc/services $./fileexist hallo
Hinweis: Eine Alternative für test [optionen] ist [ optionen ] statt "if test -e $1" alternativ "if [ -e $1 ]
Bsp: Lese- und Schreibrecht auf Datei prüfen if test -r datei1 -a -w datei1 then echo Vollzugriff fi
Bsp: Prüfen ob root das Skript ausführt (nur Bsp. für Zeichenkettenvergleich, keine gute Methode um auf root zu prüfen) if test $LOGNAME = root then echo Achtung, ihr Anmeldename ist root fi
Bsp: (im skript) Prüfen ob beim Aufruf eines Skripts genau 1 Argument übergeben wurde if test $# -ne 1 then echo Falsche Anzahl der Argumente fi ./skript arg1 -> $# = 1
Die case-Anweisung vergleicht einen Wert mit mehreren Suchmustern
case wert in muster1) befehlsliste1 ...... ;; muster2) befehlsliste2 ...... ;; ...... [ *) befehlsliste3] esac
Schleifen
Die for - Schleife
for laufvariable in werteliste do befehl1 ... ... done
Bsp: ein Skript soll 5 Zahlenwerte aufsummieren #! /bin/bash for x in 10 20 30 40 50 do summe=$[$summe + $x] echo $x done echo ------ echo $summe
Hinweis: Ohne Werteliste verwendet for die Argumente des Skriptaufrufs als Werteliste Bsp: Ein Skript newuser soll mehrere Benutzernamen als Argument übergeben bekommen und so Benutzer erstellen Aufruf: ./newuser max egon heidi #! /bin/bash for user do useradd -m $user passwd $user echo $user wurde angelegt, Passwort für $user wurde gesetzt echo ------------------------------------------------------ done
