Oracle Solaris Administration

Keine Treffer – Suchbegriff anpassen.

💻System- & Hardware-Informationen

uname -a	Alles auf einmal: OS, Hostname, Release, Version, Architektur
uname -r / uname -v	Release `5.11` bzw. Version `11.4` (S10: `5.10` / `Generic_150400-xx`)
uname -p / uname -i / uname -m	Prozessorarchitektur (`sparc`/`i386`), Plattform, Hardwareklasse
cat /etc/release	Genauer OS-Stand, z. B. `Oracle Solaris 11.4.42.111.0`
pkg info entire	Solaris 11: exakte SRU-/Build-Version des Systems
pkg list entire	Kurzform mit FMRI der installierten Support-Repository-Update
showrev -p	Installierte Patches (nur Solaris 10, in 11 durch `pkg` ersetzt)
showrev -a	Kompletter Systemsteckbrief inkl. Hostid, Kernel, Netz (Solaris 10)
prtconf	Gerätebaum und Speichergröße (`Memory size:` in der ersten Zeile)
prtconf -v \| more	Gerätebaum mit allen Properties (WWN, Modelle, Treiber)
prtconf -D	Gerätebaum mit zugehörigem Treibernamen je Knoten
prtdiag -v	Konfiguration und Fehlerstatus der Hardware (CPU, DIMM, PSU, FRU)
psrinfo	Alle Strands/vCPUs mit Status `on-line`/`off-line`
psrinfo -vp	Physische Sockets, Cores, Threads und Taktfrequenz – wichtigster CPU-Check
psrinfo -t	Nur die Anzahl der Prozessoren (skriptfreundlich)
isainfo -kv	Kernel-Bitbreite und Instruktionssatz-Erweiterungen
isainfo -b	Nur `64` oder `32` – Kernel-Bits
sysdef \| more	Kernel-Konfiguration, Module, Tunables, Pseudo-Devices
hostid	Hexadezimale Host-ID (Lizenzbindung, Cluster-Identifikation)
hostname / nodename	Hostname (in 11 über `svc:/system/identity:node` gesetzt)
svccfg -s identity:node setprop config/nodename = astring: sol01	Hostname in Solaris 11 dauerhaft ändern, danach `svcadm refresh`/`restart`
kstat -p unix:0:system_misc:boot_time	Bootzeitpunkt als Unix-Timestamp aus dem Kernel
kstat -m cpu_info -s brand	CPU-Bezeichnung je Strand aus dem Kernel-Statistik-Framework
kstat -p zfs:0:arcstats:size	Aktuelle Größe des ZFS-ARC in Bytes
virtinfo / virtinfo -a	Solaris 11: Läuft das System nativ, als LDom, Kernel Zone oder Zone?
eeprom	Alle OBP-/NVRAM-Variablen aus dem laufenden System lesen
eeprom boot-device	Einzelne OBP-Variable abfragen (SPARC)
date; uptime; who -b	Zeit, Laufzeit, Load Average, letzter Boot
iostat -En	Alle Platten mit Hersteller, Serie, Größe und Fehlerzählern
cfgadm -al	Alle Attachment Points (Controller, Platten, PCI, USB) mit Status
fmadm faulty	Aktive Hardware-/Software-Diagnosen der Fault Management Architecture
format < /dev/null	Plattenliste anzeigen, ohne in das interaktive Menü zu gehen
diskinfo	Solaris 11: kompakte Plattenliste mit Typ, Größe und Chassis-Position
croinfo	Solaris 11: Chassis/Receptacle/Occupant-Zuordnung der Datenträger
smbios -t SMB_TYPE_SYSTEM	x86: Hersteller, Modell, Seriennummer, UUID aus dem BIOS

Praxis: Ist-Zustand vor jedem Change sichern: prtdiag -v > /var/tmp/prtdiag_$(date +%F).txt, dazu pkg info entire, zpool status, ipadm show-addr und svcs -xv ablegen.

Version erkennen: uname -r liefert bei Solaris 10 und 11 jeweils 5.10/5.11. Verlässlich ist cat /etc/release; existiert /usr/bin/pkg und beadm, ist es Solaris 11.

⏻Boot, OBP/GRUB & Boot Environments

Herunterfahren & Neustarten

shutdown -y -g0 -i6	Sofortiger Reboot ohne Wartezeit (`-i5` = ausschalten, `-i0` = OBP)
shutdown -y -g300 -i5 "Wartung"	In 5 Minuten herunterfahren mit Meldung an alle User
init 6 / init 0 / init 5	Reboot / Stop (SPARC: `ok>`-Prompt) / Power off
init s / init 1	Single-User-Modus (entspricht Milestone `single-user`)
reboot	Schneller Reboot ohne saubere rc-Skripte – nur wenn bewusst gewollt
reboot -- -s	Reboot direkt in den Single-User-Modus
reboot -p	Reboot über die Plattform-Firmware (Fast Reboot umgehen)
reboot -f	Fast Reboot erzwingen (Kernel lädt Kernel, ohne POST)
halt / poweroff	Hart anhalten bzw. ausschalten (keine Dienste-Abmeldung)
who -r	Aktuellen Runlevel anzeigen
svcs -a \| grep milestone	Erreichte Milestones (Solaris-11-Äquivalent zu Runleveln)
svcadm milestone svc:/milestone/multi-user-server:default	Zielzustand temporär setzen (`-d` = dauerhaft als Default)
svcadm milestone none	Alle Dienste außer dem SMF-Kern stoppen (Notfall-Analyse)

SPARC: OpenBoot PROM (OBP)

Stop-A bzw. ~# / #. an der Konsole	In den `ok>`-Prompt wechseln (ALOM/ILOM: `break`)
ok> banner	Modell, Firmware-Version, RAM, Ethernet-Adresse, Host-ID
ok> printenv	Alle NVRAM-Variablen mit aktuellem und Default-Wert
ok> printenv boot-device	Konfigurierte Bootreihenfolge anzeigen
ok> setenv boot-device disk1 disk0	Bootreihenfolge setzen (Reihenfolge = Priorität)
ok> setenv auto-boot? false	Automatischen Boot abschalten (Wartung)
ok> devalias	Alle Geräte-Aliase (`disk0`, `net0`, `rootmirror`…)
ok> nvalias rootmirror /pci@0/…/disk@1	Eigenen, reboot-festen Alias anlegen (`nvunalias` entfernt ihn)
ok> show-disks	Interaktive Liste der Plattenpfade zum Kopieren
ok> probe-scsi-all	Alle SCSI-/SAS-Geräte scannen (nur bei gestopptem OS!)
ok> boot	Normaler Boot von `boot-device`
ok> boot -s	Boot in den Single-User-Modus
ok> boot -r	Reconfiguration Boot – neue Hardware wird eingelesen
ok> boot -m verbose	Ausführliche SMF-Meldungen beim Start (Fehlersuche)
ok> boot net - install	Netzinstallation über Automated Installer / JumpStart
ok> boot cdrom -s	Von Medium in den Single-User-Modus (Rettungsboot)
ok> boot -L	Liste der Boot Environments zur Auswahl anzeigen (ZFS-Root)
ok> boot -Z rpool/ROOT/solaris-1	Gezielt ein bestimmtes Boot Environment starten
ok> reset-all	Firmware neu initialisieren (nach `setenv` empfohlen)

x86: GRUB2 & bootadm

bootadm list-menu	Alle Boot-Einträge mit Default und Timeout (ab Solaris 11.1 GRUB2)
bootadm change-entry -i 2 default	Default-Boot-Eintrag umstellen
bootadm set-menu timeout=10	GRUB-Timeout setzen
bootadm update-archive	Boot-Archiv neu erzeugen (Pflicht nach Treiber-/Kerneleingriff)
bootadm update-archive -R /a	Boot-Archiv eines gemounteten Alt-Systems reparieren
bootadm install-bootloader	Bootloader neu schreiben (x86 GRUB2 bzw. SPARC `bootblk`)
bootadm install-bootloader -P rpool	Auf alle Platten eines gespiegelten Root-Pools schreiben
/rpool/boot/grub/menu.conf	Von `bootadm` verwaltete GRUB2-Konfiguration – nicht direkt editieren
e am GRUB-Eintrag, dann `-s` in der kernel-Zeile	Einmalig in den Single-User-Modus booten

Boot Environments (beadm)

beadm list	Alle BEs mit Aktiv-Flag (`N`=now, `R`=reboot), Größe, Datum
beadm list -a	Zusätzlich Datasets, Snapshots und Mountpoints
beadm create solaris-vor-sru	Klon des laufenden BE anlegen – der sichere Rollback vor Updates
beadm create -e solaris solaris-test	Neues BE aus einem anderen BE erzeugen
beadm activate solaris-vor-sru	BE als Default für den nächsten Boot markieren
beadm mount solaris-vor-sru /mnt	BE im laufenden System mounten (Dateien vergleichen/retten)
beadm unmount solaris-vor-sru	BE wieder aushängen
beadm rename alt neu	BE umbenennen
beadm destroy -F solaris-test	BE samt Snapshots löschen (`-F` ohne Rückfrage)
zfs list -r rpool/ROOT	BEs auf ZFS-Ebene: jedes BE ist ein Dataset unter `rpool/ROOT`

Goldene Regel für Updates: Vor jedem pkg update ein Boot Environment anlegen. Geht etwas schief, reicht beadm activate <alt> plus Reboot – kein Restore, kein Bandlaufwerk, Minuten statt Stunden.

Reihenfolge merken: beadm activate wirkt erst beim nächsten Boot (Spalte R in beadm list). Der laufende Kernel bleibt unverändert.

🛠SMF – Service Management Facility

Status abfragen

svcs	Alle aktivierten Service-Instanzen mit Status und Startzeit
svcs -a	Wirklich alle Instanzen, auch `disabled`
svcs -xv	Nur Probleme, mit Ursache, Logpfad und blockierender Abhängigkeit – erster Griff bei Störungen
svcs -x -v svc:/network/ssh:default	Erklärung zu genau einer Instanz
svcs -l ssh	Langformat: FMRI, Zustand, Restarter, Contract-ID, alle Dependencies
svcs -p ssh	Zum Service gehörende Prozesse mit PID
svcs -d ssh	Dienste, von denen `ssh` abhängt (Dependencies)
svcs -D nfs/server	Dienste, die von `nfs/server` abhängen (Dependents)
svcs -H -o state,fmri "apache"	Ohne Kopfzeile, eigene Spalten – skriptfreundlich
svcs -o fmri,state,stime -a \| grep maintenance	Alle Dienste im Zustand `maintenance` finden
svcs -L ssh	Pfad der Logdatei der Instanz ausgeben
svcs -Lv ssh \| tail -40	Logdatei direkt anzeigen (Kurzform zu `tail /var/svc/log/…`)

Dienste steuern

svcadm enable ssh	Dienst dauerhaft aktivieren und starten
svcadm enable -t ssh	Nur temporär bis zum Reboot aktivieren
svcadm enable -r nfs/server	Rekursiv: alle fehlenden Abhängigkeiten mit aktivieren
svcadm enable -s ssh	Synchron warten, bis der Dienst online ist
svcadm disable ssh	Dienst dauerhaft deaktivieren und stoppen
svcadm restart ssh	Dienst neu starten (Prozess wird beendet und gestartet)
svcadm refresh ssh	Konfiguration neu einlesen, ohne den Dienst zu stoppen
svcadm mark maintenance apache24	Dienst bewusst außer Betrieb setzen (z. B. für Wartung)
svcadm mark -I degraded apache24	Zustand nur für die laufende Instanz markieren
svcadm clear apache24	Nach behobenem Fehler aus `maintenance` herausholen
svcadm disable -s apache24; svcadm enable -s apache24	Sauberer Kaltstart eines hängenden Dienstes

Konfiguration: svccfg & svcprop

svcprop -p config ssh	Alle Properties der Gruppe `config` lesen
svcprop -p start/exec apache24	Konkretes Startkommando eines Dienstes anzeigen
svccfg -s ssh listprop	Komplette Property-Liste einer Instanz
svccfg -s ssh listprop 'config/*'	Nur eine Property-Gruppe filtern
svccfg -s site/myapp setprop config/logdir = astring: /var/log/myapp	Property setzen (Typ mit angeben)
svccfg -s site/myapp refresh	Geänderte Properties ins laufende Repository übernehmen
svccfg -s site/myapp delprop config/logdir	Property wieder entfernen
svccfg export ssh > /var/tmp/ssh.xml	Manifest einer Instanz exportieren (Backup vor Änderungen)
svccfg import /var/tmp/myapp.xml	Manifest importieren bzw. aktualisieren
svccfg delete site/myapp	Service komplett aus dem SMF-Repository entfernen
svccfg validate /var/tmp/myapp.xml	Manifest gegen das DTD prüfen, ohne zu importieren
svcadm restart manifest-import	Neue Manifeste aus den Standardverzeichnissen einlesen

Dateien & Legacy

/var/svc/log/<fmri>.log	Logdatei je Service – enthält Start-/Stop-Ausgaben und Fehler
/var/svc/log/svc.startd.log	Protokoll des Master-Restarters (Abhängigkeiten, Timeouts)
/lib/svc/manifest/	Solaris 11: von Paketen gelieferte Manifeste
/var/svc/manifest/	Solaris 10: Manifest-Verzeichnis (in 11 für Eigenbau/Site)
/lib/svc/method/	Start-/Stop-Methodenskripte der Dienste
svcs -a \| grep lrc:	Legacy-Run-Control-Skripte aus `/etc/rc*.d` (nicht von SMF gesteuert)
inetadm	Alle von `inetd` verwalteten Dienste mit Status
inetadm -l telnet	Alle Properties eines inetd-Dienstes anzeigen
inetadm -m telnet tcp_wrappers=TRUE	Property eines inetd-Dienstes ändern
inetadm -e / -d ftp	inetd-Dienst aktivieren / deaktivieren

Anti-Pattern: Startskripte in /lib/svc/method nicht manuell aufrufen. SMF glaubt dann, der Dienst sei aus, und der Restarter greift nicht. Immer über svcadm arbeiten und Fehler mit svcs -xv diagnostizieren.

maintenance vs. offline: maintenance = der Dienst selbst ist gescheitert (Log lesen, dann svcadm clear). offline = eine Abhängigkeit ist nicht erfüllt – dann mit svcs -d die Ursache suchen, nicht den Dienst.

📦Software: IPS (pkg) & SVR4 (Solaris 10)

Abfragen

pkg list	Alle installierten Pakete mit Version und Status
pkg list -a "apache"	Verfügbare Pakete im Repository suchen
pkg list -af entire	Alle Versionen (auch ältere) eines Pakets auflisten
pkg list -u	Nur Pakete, für die ein Update vorliegt
pkg info bash	Details zum installierten Paket (Version, Größe, Publisher, FMRI)
pkg info -r apache-24	Details eines noch nicht installierten Pakets aus dem Repo
pkg search -l /usr/bin/vmstat	Welches installierte Paket liefert diese Datei?
pkg search -r /usr/sbin/dtrace	Suche im Remote-Repository nach einer Datei
pkg contents -m bash	Komplettes Manifest eines Pakets (Actions, Dateien, Abhängigkeiten)
pkg contents -H -o path bash	Nur die Dateiliste eines Pakets
pkg contents -t depend -o fmri entire	Abhängigkeiten eines Pakets anzeigen
pkg verify	Konsistenzprüfung aller Pakete (Rechte, Checksummen, fehlende Dateien)
pkg verify -v bash	Einzelnes Paket detailliert prüfen
pkg fix bash	Gefundene Abweichungen aus dem Repository reparieren
pkg history	Alle Paketoperationen mit Datum, Ergebnis und User
pkg history -l -t 2026-08-18T00:00:00	Langformat ab Zeitpunkt inkl. verwendeter Kommandozeile

Installieren & Updaten

pkg install nmap	Paket installieren (Abhängigkeiten automatisch)
pkg install -nv nmap	Testlauf (Dry-Run) mit ausführlicher Planung – nichts wird geändert
pkg install --accept solaris-desktop	Lizenzen automatisch akzeptieren (Group-Pakete)
pkg uninstall nmap	Paket entfernen
pkg update	Komplettes System auf den aktuellen SRU-Stand bringen
pkg update -nv	Update planen und anzeigen, ohne es auszuführen – immer zuerst!
pkg update --be-name s11.4-sru42	Update in ein neues, sprechend benanntes Boot Environment
pkg update --require-new-be	Update erzwingt ein neues BE (Rollback bleibt möglich)
pkg update --no-be-activate	Neues BE anlegen, aber noch nicht für den Boot aktivieren
pkg update entire@11.4-11.4.42.0.0.111.0	Gezielt auf einen definierten SRU-Stand aktualisieren
pkg update pkg:/network/ssh	Nur ein einzelnes Paket aktualisieren
pkg avoid pkg:/paket / pkg unavoid	Paket von automatischer Installation ausnehmen bzw. wieder zulassen
pkg freeze -c "Change 4711" bash / pkg unfreeze bash	Version einfrieren, damit Updates sie nicht anfassen
pkg mediator -a	Alternativen (z. B. Java-, Python-, mysql-Version) anzeigen
pkg set-mediator -V 11 java	Standardversion einer Alternative festlegen
pkg rebuild-index	Suchindex neu bauen (wenn `pkg search` nichts findet)

Publisher & Repositories

pkg publisher	Konfigurierte Publisher mit Origin-URI und Reihenfolge
pkg publisher solaris	Details eines Publishers inkl. Zertifikate und Proxy
pkg set-publisher -G '*' -g http://ips.intern/solaris/ solaris	Alle alten Origins entfernen und einen neuen setzen
pkg set-publisher -g file:///mnt/repo solaris	Lokales Repository (ISO/Verzeichnis) als Quelle nutzen
pkg set-publisher --search-first solaris	Suchreihenfolge der Publisher ändern
pkg unset-publisher extra	Publisher entfernen
pkg refresh --full	Publisher-Metadaten komplett neu laden
pkgrepo info -s /export/repo	Inhalt und Paketanzahl eines lokalen Repositories
pkgrepo list -s /export/repo 'entire*'	Enthaltene Versionen eines Pakets im Repo
pkgrepo verify -s /export/repo	Repository auf Integrität prüfen
pkgrepo rebuild -s /export/repo	Repository-Katalog und Suchindex neu erzeugen
pkgrecv -s http://pkg.oracle.com/… -d /export/repo '*'	Repository spiegeln bzw. einzelne Pakete herunterladen
pkgrecv -s /export/repo -d /var/tmp --raw pkg:/bash	Paket als Rohmanifest extrahieren (Analyse)
svcadm enable application/pkg/server	Lokalen IPS-Repository-Server bereitstellen (Port 80/tcp)

Solaris 10: SVR4-Pakete & Patches

pkginfo \| wc -l	Installierte SVR4-Pakete zählen (nur Solaris 10)
pkginfo -l SUNWcsu	Details eines SVR4-Pakets (nur Solaris 10)
pkgchk -l -p /usr/bin/vmstat	Zu welchem Paket gehört die Datei? (nur Solaris 10)
pkgadd -d /var/spool/pkg SUNWxyz	Paket aus Verzeichnis installieren (nur Solaris 10)
pkgadd -d ./paket.pkg all	Alle Pakete eines Datastreams installieren (nur Solaris 10)
pkgrm SUNWxyz	Paket entfernen (nur Solaris 10)
showrev -p \| grep 148888	Prüfen, ob ein Patch installiert ist (nur Solaris 10)
patchadd -p	Alle installierten Patches auflisten (nur Solaris 10)
patchadd /var/tmp/148888-03	Patch einspielen (nur Solaris 10)
patchadd -M /var/tmp patchlist	Mehrere Patches aus Liste einspielen (nur Solaris 10)
patchrm 148888-03	Patch zurücknehmen (nur Solaris 10)
smpatch analyze / smpatch update	Patch-Empfehlungen ermitteln und einspielen (nur Solaris 10)
/var/sadm/pkg/ und /var/sadm/patch/	Paket- bzw. Patch-Datenbank von Solaris 10

Update-Standardablauf 11.4: pkg publisher prüfen → pkg update -nv → beadm create (bzw. pkg update --be-name) → pkg update → Reboot → pkg info entire und svcs -xv kontrollieren.

Merke: pkg update legt bei Kernel-relevanten Änderungen automatisch ein neues BE an. Wird die Aktion „im laufenden System“ ausgeführt, gibt es keinen Rollback – deshalb bei größeren Updates --require-new-be verwenden.

🗃ZFS – Storage Pools (zpool)

Status & Übersicht

zpool list	Alle Pools mit Größe, Alloc, Free, Fragmentierung, CAP, HEALTH
zpool list -v	Zusätzlich alle vdevs eines Pools
zpool status	Zustand aller Pools mit Redundanz, Fehlerzählern und Hinweisen
zpool status -v rpool	Detailliert, inkl. Liste beschädigter Dateien
zpool status -x	Nur Pools mit Problemen – ideal für Monitoring-Skripte
zpool status -D tank	Dedup-Statistik des Pools (DDT-Größe beachten)
zpool iostat 2	I/O-Statistik je Pool im 2-Sekunden-Takt
zpool iostat -v tank 5	I/O aufgeschlüsselt nach vdev und Einzelplatte
zpool history	Alle ändernden Kommandos, die je auf dem Pool liefen
zpool history -il tank	Inklusive interner Ereignisse, mit User und Hostname
zpool get all rpool	Alle Pool-Properties (autoexpand, version, failmode…)
zpool set autoexpand=on tank	Pool wächst automatisch mit, wenn LUNs vergrößert werden
zpool set failmode=continue tank	Verhalten bei Totalausfall (`wait`/`continue`/`panic`)
zpool upgrade -v	Verfügbare Pool-Versionen mit Feature-Liste
zpool upgrade tank	Pool auf aktuelle Version heben (danach kein Zugriff mit älterem OS!)

Pools anlegen & erweitern

zpool create tank mirror c0t1d0 c0t2d0	Mirror-Pool aus zwei Platten
zpool create tank mirror c1t0d0 c1t1d0 mirror c1t2d0 c1t3d0	Zwei Mirror-vdevs (Striping darüber) – typischer DB-Layout
zpool create tank raidz c1t0d0 c1t1d0 c1t2d0	RAIDZ1 (einfache Parität)
zpool create tank raidz2 c1t0d0 c1t1d0 c1t2d0 c1t3d0	RAIDZ2 (doppelte Parität, Standard für große Platten)
zpool create -n tank mirror c0t1d0 c0t2d0	Testlauf: geplantes Layout anzeigen, nichts anlegen
zpool create -o autoexpand=on -O compression=lz4 tank …	Pool- (`-o`) und Dataset-Properties (`-O`) direkt setzen
zpool add tank mirror c1t4d0 c1t5d0	Pool um ein weiteres vdev erweitern (Kapazität wächst)
zpool attach tank c0t1d0 c0t3d0	Platte an bestehende hängen → Mirror wird gebildet (Resilver)
zpool detach tank c0t3d0	Spiegelhälfte aus dem Mirror herauslösen
zpool add tank spare c1t9d0	Hot Spare hinzufügen (greift bei Plattenausfall automatisch)
zpool add tank log mirror c2t0d0 c2t1d0	Separates ZIL (SLOG) für synchrone Schreibvorgänge
zpool add tank cache c2t2d0	L2ARC-Cache-Device (Lese-Cache auf SSD)
zpool remove tank c1t9d0	Spare, Cache oder Log-Device entfernen
zpool split tank tank_kopie	Mirror aufteilen und aus einer Hälfte einen neuen Pool erzeugen

Fehlerbehandlung & Wartung

zpool scrub tank	Alle Blöcke lesen und gegen Checksummen prüfen (online möglich)
zpool scrub -s tank	Laufenden Scrub abbrechen
zpool clear tank	Fehlerzähler zurücksetzen, nachdem die Ursache behoben ist
zpool clear tank c1t2d0	Nur eine Platte wieder in Betrieb nehmen
zpool offline tank c1t2d0	Platte kontrolliert aus dem Pool nehmen (vor Tausch)
zpool online tank c1t2d0	Platte wieder aufnehmen, Resilver startet automatisch
zpool online -e tank c1t2d0	Vergrößerte LUN erkennen, wenn `autoexpand=off` ist
zpool replace tank c1t2d0	Platte an gleicher Position ersetzen (nach Hot-Swap)
zpool replace tank c1t2d0 c1t8d0	Defekte Platte durch eine andere ersetzen
zpool labelclear -f /dev/rdsk/c1t8d0s0	Alte ZFS-Labels von einer Platte entfernen

Import & Export

zpool export tank	Pool sauber abmelden (vor Umzug auf anderen Server)
zpool import	Importierbare Pools suchen und anzeigen
zpool import -d /dev/dsk	In einem bestimmten Verzeichnis nach Pools suchen
zpool import tank	Pool importieren
zpool import -f tank	Import erzwingen, wenn der Pool auf einem anderen Host aktiv war
zpool import tank tank_alt	Pool unter neuem Namen importieren (Namenskonflikt vermeiden)
zpool import -R /a rpool	Mit alternativem Root importieren – Rettung von außen
zpool import -N tank	Importieren, aber Dateisysteme nicht mounten
zpool import -D tank	Bereits zerstörten Pool wiederherstellen (wenn Labels intakt)

zpool import -f: Das Flag übergeht die Hostid-Sperre. Ist der Pool noch auf dem anderen Knoten aktiv, droht Datenkorruption. Erst zweifelsfrei prüfen, dass der Fremdhost aus ist bzw. den Pool nicht mehr hält.

Routine: zpool status -x täglich per Cron, zpool scrub monatlich (Enterprise-Platten) bzw. wöchentlich (Consumer/große SATA). Ein Scrub findet „stille“ Bitfehler, bevor sie beim Resilver zum Datenverlust führen.

Redundanz-Faustregeln: Mirror für IOPS/Datenbanken und schnellen Resilver, RAIDZ2 für Kapazität/Archive. RAIDZ1 bei Platten > 4 TB nicht mehr verwenden – die Resilver-Dauer macht das Risiko zu groß.

🧩ZFS – Dateisysteme, Snapshots & Klone

Datasets anlegen & anzeigen

zfs list	Alle Datasets mit USED, AVAIL, REFER, MOUNTPOINT
zfs list -r tank/data	Rekursiv ab einem Punkt im Baum
zfs list -o name,used,quota,mountpoint	Eigene Spaltenauswahl
zfs list -t filesystem,volume,snapshot	Nach Typ filtern
zfs create tank/data	Dateisystem anlegen – wird sofort gemountet
zfs create -p tank/app/prod/logs	Alle fehlenden Ebenen mit anlegen
zfs create -o compression=lz4 -o quota=100g tank/data	Mit Properties direkt bei der Anlage
zfs create -V 16g rpool/swap1	ZFS-Volume (zvol) anlegen, z. B. für Swap oder Raw-Devices
zfs destroy tank/data	Dataset löschen (muss leer von Kindern und Snapshots sein)
zfs rename tank/data tank/data_alt	Dataset umbenennen bzw. im Baum verschieben
zfs mount -a / zfs umount tank/data	Alle ZFS-Dateisysteme mounten / eines aushängen
zfs mount	Aktuell gemountete ZFS-Dateisysteme anzeigen

Properties

zfs get all tank/data	Alle Properties mit Quelle (local, inherited, default)
zfs get -r compressratio tank	Erreichtes Kompressionsverhältnis rekursiv
zfs get -H -o value used tank/data	Einzelwert ohne Kopfzeile (Skripting)
zfs set mountpoint=/data tank/data	Mountpoint setzen – kein `/etc/vfstab`-Eintrag nötig
zfs set mountpoint=legacy tank/data	Mount über `/etc/vfstab` und `mount` steuern
zfs set quota=200g tank/data	Harte Obergrenze inkl. Snapshots und Kinder
zfs set refquota=150g tank/data	Obergrenze nur für die Nutzdaten, ohne Snapshots
zfs set reservation=50g tank/data	Platz fest reservieren (garantierte Kapazität)
zfs set refreservation=50g tank/data	Reservierung ohne Snapshots/Kinder
zfs set userquota@rene=20g tank/home	Quota je Benutzer (`groupquota@` für Gruppen)
zfs userspace tank/home	Belegung je Benutzer auswerten
zfs set compression=lz4 tank/data	Kompression aktivieren (gilt nur für neu geschriebene Blöcke)
zfs set recordsize=8k tank/oradata	Blockgröße an DB-Blockgröße anpassen (vor dem Befüllen setzen!)
zfs set logbias=throughput tank/oradata	ZIL-Verhalten für große sequentielle Writes optimieren
zfs set primarycache=metadata tank/oradata	ARC nur für Metadaten nutzen (DB hat eigenen Cache)
zfs set atime=off tank/data	Access-Time-Updates abschalten (weniger Schreib-I/O)
zfs set copies=2 tank/wichtig	Jeden Block doppelt speichern (zusätzlich zur vdev-Redundanz)
zfs set readonly=on tank/archiv	Dataset schreibgeschützt setzen
zfs set snapdir=visible tank/data	`.zfs`-Verzeichnis sichtbar machen
zfs inherit -r compression tank/data	Lokale Property löschen und wieder erben

Snapshots, Klone & Rollback

zfs snapshot tank/data@2026-08-18	Snapshot anlegen – sekundenschnell, kostet zunächst keinen Platz
zfs snapshot -r tank@vor_change	Rekursiv über alle Kinder, atomar zum gleichen Zeitpunkt
zfs list -t snapshot -o name,used,creation -r tank	Alle Snapshots mit Platzverbrauch und Datum
ls /data/.zfs/snapshot/2026-08-18/	Snapshot-Inhalt direkt lesen – Datei einfach zurückkopieren
zfs diff tank/data@vor_change tank/data	Welche Dateien wurden seit dem Snapshot geändert (M/+/-/R)?
zfs rollback tank/data@vor_change	Dataset auf den Snapshot zurücksetzen (neuere Daten sind weg)
zfs rollback -r tank/data@alt	Alle jüngeren Snapshots mit verwerfen
zfs clone tank/data@snap tank/data_test	Beschreibbaren Klon erzeugen (teilt Blöcke mit dem Snapshot)
zfs promote tank/data_test	Klon vom Ursprungs-Snapshot lösen – Original wird löschbar
zfs hold keep tank/data@wichtig	Snapshot gegen Löschen sperren
zfs holds tank/data@wichtig / zfs release keep …	Sperren anzeigen / aufheben
zfs destroy tank/data@2026-08-18	Einzelnen Snapshot löschen
zfs destroy tank/data@snap1%snap5	Snapshot-Bereich in einem Schritt löschen
zfs destroy -n -v -r tank/data	Testlauf: was würde rekursiv gelöscht? Immer zuerst ausführen!

Replikation & Delegation

zfs send tank/data@snap > /backup/data.zfs	Vollstream in eine Datei schreiben
zfs send -R tank/data@snap \| zfs recv -Fdu tank2	Kompletter Baum inkl. Properties und Snapshots replizieren
zfs send -i @alt tank/data@neu \| ssh srv2 zfs recv tank/data	Inkrementell – nur die Differenz zwischen zwei Snapshots
zfs send -I @alt tank/data@neu \| …	Inkrementell inkl. aller Zwischen-Snapshots
zfs send -nv -R tank/data@snap	Größe des Streams schätzen, ohne zu senden
zfs recv -F tank2/data	Ziel vor dem Empfang auf den Stand des Streams zurückrollen
zfs recv -u tank2/data	Empfangenes Dataset nicht mounten (wichtig auf dem Zielserver)
zfs allow rene snapshot,mount,create tank/home	Rechte an einen Nicht-Root-User delegieren
zfs allow tank/home / zfs unallow rene tank/home	Delegationen anzeigen / zurücknehmen
zfs upgrade / zfs upgrade -a	Dataset-Version anzeigen bzw. alle heben

zfs destroy -r ist gefährlich: Es löscht rekursiv alle Kind-Datasets, Snapshots und abhängige Klone. Immer erst zfs destroy -n -v -r als Testlauf laufen lassen und die Ausgabe lesen.

ARC frisst RAM – absichtlich: Freier Speicher wird als ZFS-Cache genutzt und bei Bedarf sofort wieder freigegeben. Prüfen mit kstat -p zfs:0:arcstats:size und arcstat 5; begrenzen nur bei DBs, die eigenen Cache brauchen (Property user_reserve_hint_pct in 11.4 statt zfs_arc_max in /etc/system).

Platz weg, aber du zeigt nichts? Fast immer Snapshots. Prüfen mit zfs list -o space -r tank – die Spalte USEDSNAP zeigt, wie viel die Snapshots halten.

📁UFS & Solaris Volume Manager (Altbestand)

UFS-Dateisysteme

df -h / df -k	Belegung aller Dateisysteme (lesbar / in KB)
df -F ufs -o i /var	Inode-Auslastung eines UFS (100 % = „voll“ trotz freiem Platz)
newfs /dev/rdsk/c1t1d0s0	UFS anlegen (Raw-Device!) – UFS nur noch für Altbestand
newfs -i 4096 /dev/rdsk/c1t1d0s0	Mehr Inodes (viele kleine Dateien)
mkfs -F ufs /dev/rdsk/c1t1d0s0 20971520	UFS mit expliziter Sektorenanzahl anlegen
mount /dev/dsk/c1t1d0s0 /data	Manuell mounten (Block-Device)
mount -F ufs -o logging /dev/dsk/c1t1d0s0 /data	Mit UFS-Logging (Journal) mounten – Standard ab Solaris 9
mount -o remount,rw /data	Mountoptionen ohne Aushängen ändern
mountall / umountall	Alle Einträge aus `/etc/vfstab` mounten / aushängen
umount /data	Aushängen (`umount -f` erzwingt)
fuser -c /data	Wer benutzt das Dateisystem (PIDs)
fuser -ck /data	Alle Zugriffe hart beenden, danach `umount`
fsck -F ufs -y /dev/rdsk/c1t1d0s0	UFS prüfen und reparieren – nur im ausgehängten Zustand!
growfs -M /data /dev/md/rdsk/d10	UFS online auf die neue Größe des Volumes erweitern
tunefs -m 2 /dev/rdsk/c1t1d0s0	Minfree-Reserve anpassen (mehr nutzbarer Platz)
lockfs -a / lockfs /data	UFS-Sperren anzeigen bzw. Status prüfen
/etc/vfstab	Mount-Tabelle – in Solaris 11 nur noch für UFS, Swap, NFS relevant
/etc/mnttab	Aktuell gemountete Dateisysteme (Kernel-Sicht, read-only)

SVM – Solaris Volume Manager (metadevices)

metadb -i	Status aller State Database Replicas (mindestens 3 nötig)
metadb -a -f -c 3 c1t0d0s7 c1t1d0s7	Je 3 Replicas auf zwei Platten anlegen (`-f` beim ersten Mal)
metadb -d c1t1d0s7	Replicas einer Platte entfernen
metastat	Status aller Metadevices mit Submirrors und Sync-Fortschritt
metastat -c	Kompakte einzeilige Übersicht je Volume
metastat -p	Ausgabe im `md.tab`-Format – ideal zur Dokumentation
metainit d10 1 1 c1t0d0s0	Einfache Konkatenation/Stripe als Submirror anlegen
metainit d0 -m d10	Mirror aus einem Submirror bilden
metattach d0 d20	Zweiten Submirror anhängen – Resync startet
metadetach d0 d20	Submirror abtrennen (z. B. für Backup-Split)
metaoffline / metaonline d0 d20	Submirror temporär deaktivieren / reaktivieren
metareplace -e d0 c1t1d0s0	Getauschte Platte wieder aufnehmen und resyncen
metaclear d0 d10 d20	Metadevices löschen (von oben nach unten)
metaroot d0	Root-Dateisystem auf ein Metadevice umstellen (passt vfstab/system an)
metaset -s dg -a -h node1 node2	Shared Diskset für Cluster anlegen
/etc/lvm/md.tab	Konfigurationsvorlage für `metainit -a`
/etc/lvm/mddb.cf	Speicherorte der State Database Replicas

ufsdump / ufsrestore

ufsdump 0uf /dev/rmt/0 /data	Level-0-Vollsicherung, Zeitstempel in `/etc/dumpdates`
ufsdump 9uf /dev/rmt/0 /data	Inkrementelle Sicherung (Level 1–9)
ufsdump 0f - /data \| gzip > /backup/data.dump.gz	In Datei sichern und komprimieren
ufsrestore -tf /backup/data.dump	Inhaltsverzeichnis eines Dumps anzeigen
ufsrestore -ivf /dev/rmt/0	Interaktiver Restore (`add`, `extract`, `quit`)
ufsrestore -rvf /dev/rmt/0	Kompletter Restore in ein leeres, gemountetes UFS

Solaris 11 und UFS: Root ist immer ZFS, UFS ist nur noch für Datenpartitionen und Migrationen relevant. SVM (metadb, metainit) existiert in 11 noch, neue Layouts gehören aber in ZFS – dort ersetzen zpool-vdevs die Metadevices.

Migration UFS → ZFS: ZFS-Dataset anlegen, dann cd /altes_ufs && find . -depth -print | cpio -pdumv /neues_zfs – hält Rechte, Links und Sparse-Struktur.

🔌Devices, Storage-Pfade & Multipathing

Geräte erkennen

devfsadm -Cv	Gerätebaum neu aufbauen und verwaiste Links (`-C`) entfernen
devfsadm -i sd	Nur für einen Treiber scannen (schneller, schonender)
devfsadm -c disk	Nur Geräte einer Klasse konfigurieren
cfgadm -al	Alle Attachment Points mit Typ, Receptacle und Occupant
cfgadm -al -o show_FCP_dev c2	Alle LUNs hinter einem FC-Controller einzeln anzeigen
cfgadm -c configure c2::5006016…	Gerät/Port in Betrieb nehmen (LUN sichtbar machen)
cfgadm -c unconfigure c2::dsk/c2t1d0	Gerät sauber abmelden (vor Ausbau/SAN-Wartung)
cfgadm -x replace_device c1::dsk/c1t2d0	Hot-Swap-Tausch einer Platte geführt durchführen
format	Interaktiv: Platten anzeigen, labeln, partitionieren, analysieren
format -e	Erweiterter Modus – EFI/GPT-Label für Platten > 2 TB
prtvtoc /dev/rdsk/c1t0d0s2	Partitionstabelle (VTOC) lesen – wichtig für Dokumentation
prtvtoc /dev/rdsk/c1t0d0s2 \| fmthard -s - /dev/rdsk/c1t1d0s2	Label 1:1 auf eine gleich große Platte kopieren
fdisk /dev/rdsk/c1t1d0p0	x86: fdisk-Partition (Solaris2) anlegen, vor `format`
rmformat -l	Wechselmedien (USB-Stick, DVD, Bandlaufwerk) auflisten
iostat -En	Alle Platten mit Serie, Größe und Hard-/Soft-/Transport-Errors
iostat -Enr	Gleiche Daten in CSV-Form (auswertbar)
/dev/dsk/cXtYdZsN und /dev/rdsk/cXtYdZsN	Block- bzw. Raw-Device einer Partition (`s2` = ganze Platte bei VTOC)
/dev/rdsk/cXtYdZ (ohne Slice)	Bei EFI-Label: `s0` bzw. der Gerätename ohne Slice

FC, SAS & Multipathing (MPxIO)

fcinfo hba-port	Alle FC-HBA-Ports mit WWN, Status, Speed, Firmware – für Zoning
fcinfo hba-port -l	Zusätzlich unterstützte Link-Geschwindigkeiten
fcinfo remote-port -p <hba-wwn> -s	Sichtbare Storage-Ports und deren LUNs
luxadm probe	Alle erkannten Storage-Arrays und Platten mit Pfad
luxadm display /dev/rdsk/c0t60…d0s2	Details einer LUN inkl. aller Pfade und deren Status
luxadm -e port	Zustand der FC-Ports (CONNECTED / NOT CONNECTED)
luxadm led_blink /dev/rdsk/c1t2d0s2	Positions-LED der Platte blinken lassen (Tausch im Rack)
mpathadm list lu	Alle Multipath-LUNs mit Anzahl gesamter und aktiver Pfade
mpathadm show lu /dev/rdsk/c0t60…d0s2	Pfaddetails: Load-Balancing, Initiator, Target-Port, Status
mpathadm list initiator-port	Alle Initiator-Ports des Systems
mpathadm modify lu -a disable -t <target-port> <lu>	Einzelnen Pfad gezielt deaktivieren
stmsboot -L	Zuordnung alter zu neuer Gerätenamen nach MPxIO-Aktivierung
stmsboot -e	MPxIO systemweit aktivieren – erfordert Reboot
stmsboot -d	MPxIO deaktivieren (Reboot)
stmsboot -D fp -e	MPxIO nur für einen Gerätetyp (hier FC) einschalten
stmsboot -u	Nach manuellen Änderungen `/etc/vfstab` und Dump anpassen
/etc/driver/drv/fp.conf, scsi_vhci.conf	Solaris 11: Treiberkonfiguration (in 10: `/kernel/drv/`)

stmsboot -e ändert Gerätenamen: Aus c2t1d0 wird c0t60060…d0. Vor der Umstellung stmsboot -L speichern, /etc/vfstab, ZFS-Pools, Dump- und Swap-Geräte prüfen und danach zwingend rebooten. ZFS findet seine Platten über Labels selbst wieder, UFS-Einträge nicht.

LUN vergrößert im Storage? cfgadm -c configure bzw. devfsadm → format → Label prüfen → zpool set autoexpand=on tank bzw. zpool online -e tank <dev>.

📈Swap, Dump & Core-Dateien

Swap

swap -l	Alle Swap-Bereiche mit Gerät, Größe und freien Blöcken
swap -s	Zusammenfassung: allocated, reserved, used, available
zfs create -V 16g rpool/swap1	Neues Swap-zvol anlegen (Solaris 11-Standardweg)
swap -a /dev/zvol/dsk/rpool/swap1	Swap sofort aktivieren
swap -d /dev/zvol/dsk/rpool/swap1	Swap deaktivieren (muss vor dem Löschen erfolgen)
swap -a /var/tmp/swapfile	Datei als Swap nutzen (Notlösung bei akutem Engpass)
zfs set volsize=32g rpool/swap	Swap-zvol vergrößern (danach `swap -d` und `swap -a`)
/etc/vfstab → /dev/zvol/dsk/rpool/swap1 - - swap - no -	Swap dauerhaft eintragen – einer der letzten vfstab-Anwendungsfälle
vmstat 5 \| awk '{print $4,$5,$7,$8}'	swap, free, page-in, page-out beobachten

Crash Dump

dumpadm	Aktuelle Dump-Konfiguration: Gerät, savecore-Verzeichnis, Modus
dumpadm -d /dev/zvol/dsk/rpool/dump	Dump-Gerät setzen (eigenes zvol, nicht Swap!)
dumpadm -s /var/crash	Zielverzeichnis für die entpackten Dumps festlegen
dumpadm -c curproc	Dump-Inhalt: `kernel`, `curproc` oder `all`
dumpadm -y / dumpadm -n	savecore beim Boot ein- bzw. ausschalten
dumpadm -z on	Dump komprimiert ablegen (spart Platz in `/var/crash`)
savecore -vf /dev/zvol/dsk/rpool/dump	Dump nachträglich aus dem Dump-Device holen
savecore -L	Live-Dump des laufenden Systems (Analyse ohne Ausfall)
ls -l /var/crash/	Vorhandene Dumps (`vmcore.N`, `unix.N` bzw. `vmdump.N`)
zfs get volsize rpool/dump	Größe des Dump-zvol prüfen – muss zum RAM passen

Core-Dateien

coreadm	Aktuelle Core-Konfiguration (Muster, global/per-process)
coreadm -e global -g /var/cores/core.%f.%p.%t	Zentrales Core-Verzeichnis mit sprechendem Namensmuster
coreadm -e log	Jeden Core-Dump im syslog protokollieren
coreadm -d process	Per-Process-Cores abschalten
coreadm -p /var/cores/core.%f.%p $$	Muster für die aktuelle Shell und Kinder setzen
pargs -a core; pstack core; pflags core	Core-Datei auswerten: Argumente, Stack, Flags
file core	Welches Programm hat den Core erzeugt?

Getrennte zvols: In Solaris 11 sind rpool/swap und rpool/dump zwei eigene Volumes. Nie das Swap-Device als Dump-Device eintragen – ein Panic würde sonst Swap-Inhalte überschreiben. Dump-Größe grob: 30–50 % des RAM bei komprimiertem Dump.

⚙Prozesse, Jobs & Zeitsteuerung

Prozesse anzeigen

ps -ef	Alle Prozesse im Full-Format
ps -ef \| grep -v grep \| grep sshd	Prozess gezielt suchen
ps -eo pid,ppid,user,pcpu,pmem,rss,args	Eigene Spaltenauswahl
ps -eo pid,rss,args \| sort -k2 -rn \| head -20	Speicherhungrigste Prozesse
ps -eo pid,pcpu,args \| sort -k2 -rn \| head -20	CPU-hungrigste Prozesse
ps -eLo pid,lwp,pcpu,args	Prozesse mit ihren LWPs/Threads
ps -ez / ps -eo zone,pid,args	Prozesse mit Zonenzuordnung (aus der Global Zone)
prstat	Interaktive Top-Ansicht der Prozesse
prstat -a	Prozesse plus Zusammenfassung je User
prstat -Lm 5	Je Thread mit Mikrostate-Accounting (LAT, TFL, DFL, LCK) – Goldstandard
prstat -Z	Zusammenfassung je Zone
prstat -J / prstat -T	Zusammenfassung je Projekt bzw. je Task
prstat -s rss -n 15 1 1	Top 15 nach Speicher, einmalige Momentaufnahme
ptree -a <pid>	Prozessbaum mit Argumenten
ptree $$	Eigene Prozesskette bis `init` anzeigen

proc-Tools (/proc-Werkzeuge)

pfiles <pid>	Alle offenen File Descriptors mit Pfad, Socket und Peer
pmap -x <pid>	Speicherabbild mit RSS je Segment (echte Speichernutzung)
pmap -S <pid>	Aufschlüsselung nach Shared/Private Memory
pstack <pid>	Stack-Trace aller Threads – erster Griff bei hängenden Prozessen
pargs -ae <pid>	Aufrufargumente und komplettes Environment eines Prozesses
pwdx <pid>	Aktuelles Arbeitsverzeichnis
pldd <pid>	Geladene Shared Libraries
psig <pid>	Signalbehandlung des Prozesses
pcred <pid>	UID/GID und Privilegien-Set des Prozesses
plimit <pid>	Ressourcen-Limits eines laufenden Prozesses anzeigen
plimit -n 8192 <pid>	Limit im laufenden Betrieb erhöhen (z. B. File Descriptors)
pstop / prun <pid>	Prozess anhalten / weiterlaufen lassen
preap <pid>	Zombie-Prozess (Status `defunct`) einsammeln
ptime -m cmd	Kommando mit Mikrostate-Zeiten messen
truss -f -o /var/tmp/t.out cmd	Systemaufrufe verfolgen, auch der Kindprozesse
truss -p <pid> -t open,stat	An laufenden Prozess anhängen, nur bestimmte Calls
truss -u ':::' -p <pid>	Zusätzlich Aufrufe in User-Libraries verfolgen

Steuern & Prioritäten

kill -TERM <pid> / kill -KILL <pid>	Sauber beenden / hart abschießen
kill -HUP <pid>	Konfiguration neu einlesen (bei Daemons ohne SMF-Refresh)
pgrep -fl apache	PIDs samt Kommandozeile suchen
pgrep -u oracle -n	Jüngster Prozess eines Users
pkill -9 -f "java.*myapp"	Alle passenden Prozesse beenden (Muster auf ganze Kommandozeile)
nice -n 10 cmd	Mit niedrigerer Priorität starten
renice -n 5 -p <pid>	Priorität eines laufenden Prozesses ändern
priocntl -l	Verfügbare Scheduling-Klassen (TS, IA, FX, RT, FSS, SDC)
priocntl -d -i pid <pid>	Scheduling-Klasse eines Prozesses anzeigen
priocntl -s -c FX -m 0 -p 40 -i pid <pid>	In die Fixed-Priority-Klasse setzen
nohup cmd > /var/tmp/log 2>&1 &	Job abgekoppelt im Hintergrund starten
jobs / fg %1 / bg %1	Shell-Jobverwaltung
ipcs -a / ipcrm -m <id>	Shared Memory, Semaphore, Queues anzeigen / entfernen

cron & at

crontab -l / crontab -e	Eigene Crontab anzeigen / bearbeiten
crontab -l oracle	Crontab eines anderen Users lesen (als root)
crontab -r	Eigene Crontab löschen – Vorsicht, keine Rückfrage
/var/spool/cron/crontabs/	Speicherort aller Crontabs (im Backup berücksichtigen)
/etc/cron.d/cron.allow, cron.deny	Wer darf `crontab` nutzen
/var/cron/log	Cron-Protokoll: was wurde gestartet, mit welchem Ergebnis
svcs -xv cron; svcadm restart cron	cron-Dienst prüfen und neu starten
at 22:00 tomorrow	Einmaligen Job planen (Ctrl-D beendet die Eingabe)
at -f /var/tmp/job.sh now + 2 hours	Skript zeitversetzt starten
atq / at -r <jobid>	Geplante at-Jobs listen / löschen

Cron-Falle: cron startet mit minimalem Environment – kein .profile, PATH nur /usr/bin. Immer absolute Pfade nutzen und nötige Variablen (PATH, ORACLE_HOME, LD_LIBRARY_PATH) im Skript selbst setzen. In Solaris 11 zusätzlich prüfen, ob der User die nötigen Rechtsprofile hat.

Hangt ein Prozess? pstack <pid> zweimal im Abstand von 10 Sekunden – ist der Stack identisch, steckt der Prozess. Dann pfiles (hängt er an einem Socket/NFS?) und truss -p.

📊Performance-Analyse & DTrace

Schnellüberblick

vmstat 5	Alle 5 s: CPU, Runqueue (`r`), Paging (`sr`, `pi`, `po`)
vmstat 5 12	12 Messungen – erste Zeile ist immer der Mittelwert seit Boot, ignorieren
vmstat -p 5	Paging nach Typ getrennt: executable, anonymous, filesystem
vmstat -s	Kumulierte Kernel-Zähler seit Boot
mpstat 5	Auslastung je vCPU: `csw`, `icsw`, `smtx`, `intr`, `idl`
mpstat -a 5	Aggregiert je Prozessorgruppe/Socket
prstat -Lm 5	Thread-Mikrostates: wo verbringt der Prozess seine Zeit?
iostat -xnz 5	I/O je Gerät, Nullzeilen unterdrückt – auf `asvc_t` und `%b` achten
iostat -xnzM 5	Gleiche Ausgabe in MB/s
iostat -xnzcp 5	Zusätzlich CPU-Anteil und Partitionsstatistik
fsstat zfs 5	Dateisystem-Operationen (lookup, read, write) je FS-Typ
fsstat /data 5	Statistik für einen einzelnen Mountpoint
arcstat 5	ZFS-ARC: Hit-Rate, Größe, Ziel (Solaris 11)
zonestat 5	Ressourcenverbrauch je Zone (CPU, RAM, Netz, Swap)
zonestat -q -r physical-memory 10 1h 1h	Eine Stunde aufzeichnen und Bericht ausgeben

sar & kstat

sar -u 5 10	CPU-Nutzung (usr, sys, wio, idle)
sar -d 5 5	Disk-Statistik mit Queue-Länge und Service-Zeit
sar -g 5 5 / sar -p 5 5	Page-out-/Page-in-Aktivität
sar -q 5 5	Runqueue- und Swap-Queue-Länge
sar -A	Alle Berichte auf einmal
sar -f /var/adm/sa/sa18	Aufzeichnung des 18. Tages auswerten
svcadm enable system/sar	Automatische sar-Datensammlung einschalten
kstat -p	Alle Kernel-Statistiken als `modul:inst:name:stat`-Paare
kstat -p 'unix:0:vopstats_zfs:*'	Gezielt eine Statistikgruppe abfragen
kstat -n nfs_client -s 'read*'	Nach Statistiknamen filtern
kstat -p -T d 5 3	Mit Zeitstempel wiederholt messen (Delta selbst bilden)
cpustat -c PAPI_tot_ins 1 5	CPU-Performance-Counter systemweit auslesen
cputrack -c <counter> -p <pid>	Performance-Counter für einen einzelnen Prozess
trapstat -t 5	SPARC: TLB-Misses und Traps – Hinweis auf Page-Size-Probleme
busstat -l / busstat -w <dev>	Bus- und Interconnect-Zähler der Plattform
lockstat -kIW sleep 10	Kernel-Profiling: wo verbringt der Kernel CPU-Zeit?
lockstat sleep 10	Kernel-Lock-Contention messen
plockstat -A -p <pid>	Userland-Mutex-/RWLock-Contention einer Anwendung
netstat -i 5	Pakete und Fehler je Interface im Intervall

DTrace

dtrace -l \| wc -l	Anzahl verfügbarer Probes (mehrere Zehntausend)
dtrace -l -P io	Alle Probes eines Providers auflisten
dtrace -n 'syscall:::entry { @[probefunc] = count(); }'	Welche Systemaufrufe dominieren? Abbruch mit Ctrl-C
dtrace -n 'syscall:::entry /execname=="java"/ { @[probefunc]=count(); }'	Nur für einen bestimmten Prozessnamen
dtrace -n 'proc:::exec-success { trace(curpsinfo->pr_psargs); }'	Alle neu gestarteten Programme mitschreiben
dtrace -n 'io:::start { @[args[1]->dev_statname] = count(); }'	I/O-Verteilung auf die Geräte
dtrace -n 'io:::start { @[execname] = sum(args[0]->b_bcount); }'	Welcher Prozess verursacht die meisten Bytes I/O?
dtrace -n 'syscall::open*:entry { printf("%s %s", execname, copyinstr(arg0)); }'	Welche Dateien werden geöffnet?
dtrace -n 'profile-997 /arg0/ { @[stack()]=count(); } tick-10s { exit(0); }'	Kernel-Stacks samplen (Hotspot finden)
dtrace -n 'sched:::off-cpu /execname=="myapp"/ { @=quantize(…) }'	Off-CPU-Analyse: worauf wartet die Anwendung?
dtrace -qs script.d	D-Skript ausführen, ohne Kopfzeilen
dtrace -c "cmd" -n 'syscall:::entry{@[probefunc]=count();}'	Nur für die Laufzeit eines gestarteten Kommandos messen
execsnoop / opensnoop / iosnoop	DTraceToolkit: Prozessstarts / Dateiöffnungen / Einzel-I/Os live
dtrace -n 'dtrace:::ERROR { }'	Eigene Skripte auf Fehler prüfen

Wo klemmt es? Reihenfolge: vmstat 5 (CPU vs. Paging) → mpstat 5 (einzelne CPU heiss? smtx hoch = Lock-Contention) → iostat -xnz 5 (asvc_t > 20 ms bei SAN = Storage) → prstat -Lm 5 (welcher Thread, welcher Mikrostate) → DTrace für die Feinanalyse.

Kennzahlen lesen: vmstat-Spalte sr (scan rate) dauerhaft > 0 bedeutet echten Speichermangel – free allein ist wegen des ARC kein Indikator. In iostat -xnz ist %b nahe 100 bei gleichzeitig niedrigen IOPS ein Zeichen für ein einzelnes langsames Gerät, nicht für Last.

🌐Netzwerk: dladm, ipadm & Routing

Datalinks (dladm, ab Solaris 11)

dladm show-phys	Physische NICs mit Medium, Status, Speed, Duplex und Gerätenamen
dladm show-phys -L	Zuordnung Linkname ↔ physischer Steckplatz/Treiberinstanz
dladm show-link	Alle Datalinks (physisch, VNIC, Aggregation, VLAN) mit MTU
dladm show-link -s -i 5	Paket-/Fehlerstatistik je Link im Intervall
dladm show-ether net0	Autonegotiation, Pause Frames, ausgehandelte Geschwindigkeit
dladm show-linkprop net0	Alle Link-Properties mit aktuellem, Default- und möglichem Wert
dladm set-linkprop -p mtu=9000 net0	Jumbo Frames setzen (Switch und Gegenstelle müssen mitspielen)
dladm set-linkprop -p speed=1000,duplex=full net0	Geschwindigkeit fest vorgeben (nur wenn wirklich nötig)
dladm set-linkprop -t -p …	`-t` = nur temporär bis zum Reboot
dladm reset-linkprop -p mtu net0	Property auf den Default zurücksetzen
dladm rename-link net0 mgmt0	Link sprechend umbenennen (Link muss ungenutzt sein)
dladm create-vlan -l net0 -v 100 vlan100	VLAN-Interface auf einem Link anlegen
dladm create-vnic -l net0 -v 100 vnic0	Virtuelle NIC (für Zonen), optional mit VLAN-Tag
dladm create-vnic -l net0 -m auto vnic0	VNIC mit automatisch generierter MAC-Adresse
dladm show-vnic	Alle VNICs mit MAC, Speed-Limit und Zonenzuordnung
dladm create-aggr -l net0 -l net1 aggr0	Link Aggregation (Trunk) aus zwei Ports
dladm create-aggr -P L2,L3 -L active -l net0 -l net1 aggr0	Mit Hash-Policy und LACP im Active-Mode
dladm show-aggr -x	Status jedes Ports in der Aggregation (LACP-Zustand!)
dladm add-aggr -l net2 aggr0 / dladm remove-aggr -l net2 aggr0	Port zur Aggregation hinzufügen / entfernen
dladm delete-aggr aggr0 / delete-vnic vnic0 / delete-vlan vlan100	Virtuelle Links wieder abbauen
dlstat -i 5	Durchsatz je Link (Pakete und Bytes, rx/tx)
dlstat show-link -r net0	Empfangsstatistik inkl. Drops je Hardware-Ring

IP-Konfiguration (ipadm, ab Solaris 11)

ipadm show-if	Alle IP-Interfaces mit Zustand und aktivierten Protokollklassen
ipadm show-addr	Alle Adressobjekte (`net0/v4`) mit Typ, Status und Adresse
ipadm show-addr -o all net0/v4	Alle Felder eines Adressobjekts
ipadm create-ip net0	IP-Interface auf dem Datalink anlegen (Schritt 1)
ipadm create-addr -T static -a local=10.0.0.10/24 net0/v4	Statische IPv4-Adresse dauerhaft setzen (Schritt 2)
ipadm create-addr -T static -a 10.0.0.11/24 net0/v4b	Zweite Adresse (Alias) auf demselben Interface
ipadm create-addr -T dhcp net0/dhcp	Adresse per DHCP beziehen
ipadm create-addr -T addrconf net0/v6	IPv6-Autokonfiguration (SLAAC) aktivieren
ipadm delete-addr net0/v4	Adressobjekt entfernen
ipadm delete-ip net0	IP-Interface komplett abbauen
ipadm disable-if -t net0 / ipadm enable-if -t net0	Interface temporär deaktivieren / reaktivieren
ipadm down-addr net0/v4 / ipadm up-addr net0/v4	Einzelne Adresse abschalten / einschalten
ipadm show-ifprop net0	Interface-Properties (mtu, forwarding, metric) je Protokoll
ipadm set-ifprop -p mtu=9000 -m ipv4 net0	MTU auf IP-Ebene setzen (zusätzlich zum Link!)
ipadm show-prop tcp	Protokoll-Tunables von TCP mit Default- und aktuellem Wert
ipadm set-prop -p send_buf=1048576 tcp	TCP-Tunable dauerhaft setzen (ersetzt `ndd`)
ipadm set-prop -p forwarding=on ipv4	IP-Forwarding einschalten (Router-Betrieb)
ipadm reset-prop -p send_buf tcp	Tunable auf Default zurücksetzen
ipadm create-ipmp ipmp0	IPMP-Gruppe anlegen (Ausfallsicherheit auf IP-Ebene)
ipadm add-ipmp -i net0 -i net1 ipmp0	Interfaces in die IPMP-Gruppe aufnehmen
ipmpstat -g / -i / -a / -t / -p	IPMP: Gruppen / Interfaces / Adressen / Targets / Probes

Routing, Namensauflösung & Analyse

netstat -rn	Routing-Tabelle numerisch
route -p add default 10.0.0.1	Default-Route persistent setzen – `-p` ist entscheidend
route -p add -net 192.168.5.0/24 10.0.0.254	Persistente statische Route
route -p delete default 10.0.0.1	Persistente Route entfernen
route -p show	Alle persistenten Routen auflisten
route get 8.8.8.8	Welche Route/Interface würde für ein Ziel genutzt?
netstat -an -f inet \| grep LISTEN	Lauschende TCP-Ports
netstat -an -P tcp	Alle TCP-Verbindungen mit Zustand
netstat -s -P tcp	TCP-Protokollstatistik (Retransmits, Resets)
arp -a / arp -d 10.0.0.5	ARP-Cache anzeigen / Eintrag löschen
ping -s 10.0.0.1 56 5	Fortlaufendes Ping mit Paketgröße und Anzahl
traceroute 10.1.2.3	Pfad zum Ziel verfolgen
snoop -d net0	Paketmitschnitt am Interface (Solaris-eigener Sniffer)
snoop -d net0 -o /var/tmp/net0.snoop host 10.0.0.5 and port 22	Gefiltert in Datei schreiben
snoop -i /var/tmp/net0.snoop -V	Mitschnitt lesen (`-v` = alle Protokollschichten)
/etc/inet/hosts (Link: /etc/hosts)	Lokale Namensauflösung
/etc/resolv.conf, /etc/nsswitch.conf	DNS-Resolver und Reihenfolge der Namensquellen
svccfg -s dns/client setprop config/nameserver = net_address: "(10.0.0.53 10.0.0.54)"	Solaris 11: DNS-Server im SMF hinterlegen
svccfg -s dns/client setprop config/search = astring: "(intern.example)"	Suchdomain setzen, danach `svcadm refresh dns/client`
svccfg -s name-service/switch setprop config/host = astring: "files dns"	nsswitch-Reihenfolge über SMF steuern
nscfg export svc:/system/name-service/switch:default	SMF-Konfiguration in die klassische Datei schreiben
nscfg import -f svc:/network/dns/client:default	Bestehende `/etc/resolv.conf` ins SMF importieren
svcadm refresh dns/client; svcadm restart name-service/cache	DNS-Einstellungen aktivieren und Cache leeren
nscd -i hosts / getent hosts sol01	Namescache für hosts invalidieren / Auflösung testen
nslookup sol01 / dig sol01.intern.example	DNS gezielt abfragen

Solaris 10: ifconfig & Konfigurationsdateien

ifconfig -a	Alle Interfaces mit IP und Flags (nur Solaris 10 als Konfigurationsweg)
ifconfig ce0 plumb 10.0.0.10 netmask 255.255.255.0 up	Interface temporär konfigurieren (nur Solaris 10, nach Reboot weg)
ifconfig ce0:1 plumb 10.0.0.11 netmask + up	Logisches Interface / Alias (nur Solaris 10)
ifconfig ce0 unplumb	Interface abbauen (nur Solaris 10)
/etc/hostname.ce0	Hostname/IP je Interface – macht die Konfiguration dauerhaft (Solaris 10)
/etc/dhcp.ce0	Leere Datei = Interface bezieht DHCP (Solaris 10)
/etc/defaultrouter, /etc/netmasks, /etc/inet/netmasks	Default-Gateway und Netzmasken (Solaris 10)
ndd -get /dev/tcp tcp_conn_req_max_q	TCP/IP-Tunable lesen (nur Solaris 10, in 11: `ipadm show-prop`)
ndd -set /dev/ip ip_forwarding 1	Tunable temporär setzen (nur Solaris 10)
svcadm restart network/physical	Netzkonfiguration neu einlesen (beide Versionen)

Persistenz – der häufigste Fehler: ipadm und dladm schreiben ihre Konfiguration persistent (außer mit -t). ifconfig dagegen ist immer nur temporär und in Solaris 11 nur noch für Diagnose gedacht. Routen brauchen zwingend route -p, sonst sind sie nach dem Reboot weg.

MTU an zwei Stellen: Jumbo Frames erfordern dladm set-linkprop -p mtu=9000 und ipadm set-ifprop -p mtu=9000 -m ipv4. Prüfen mit ping -s -D <host> 8972 (Don't-Fragment).

Netzprofil: In Solaris 11 gibt es svc:/network/physical:default (manuell, ipadm/dladm) und :nwam (automatisch, für Laptops). Auf Servern muss default aktiv sein – sonst überschreibt NWAM die Konfiguration.

🛡Firewall & Netzwerk-Sicherheit

Packet Filter (PF) – Solaris 11.4

pkg install firewall	PF-Paket installieren (ab 11.4 der Nachfolger von IP Filter)
/etc/firewall/pf.conf	Standard-Regelwerk (Default-Set schaltet nur `set skip on lo0`)
pfctl -n -f /etc/firewall/pf.conf	Syntaxprüfung, ohne die Regeln zu laden – immer zuerst!
svcadm enable firewall	Firewall-Dienst aktivieren (lädt `pf.conf` und ruft `pfctl -e`)
svcadm refresh firewall	Geändertes Regelwerk neu laden
svccfg -s firewall listprop firewall/rules	Welche Regeldatei nutzt der Dienst?
pfctl -s rules	Geladene Filterregeln anzeigen
pfctl -s nat	Aktive NAT-/Redirect-Regeln
pfctl -s state	Aktuelle Verbindungszustände (State Table)
pfctl -s info	Zähler: passed, blocked, State-Table-Auslastung
pfctl -s all	Komplette Diagnoseausgabe
pfctl -vvs rules	Regeln mit Trefferzählern – findet nie greifende Regeln
pfctl -F state / pfctl -F rules	State-Table bzw. Regeln leeren (Vorsicht im Produktivbetrieb)
pfctl -e / pfctl -d	Paketfilter ein-/ausschalten (der Dienst tut das normalerweise)
pfctl -t badhosts -T show	Inhalt einer PF-Tabelle anzeigen (`-T add`/`-T delete`)
ipf2pf -4 /etc/ipf/ipf.conf	Bestehende IPF-Regeln nach PF konvertieren (Migrationshilfe)
svcadm enable network/pflog; /var/log/firewall/pflog/	PF-Logging aktivieren und Mitschnitte auswerten

IP Filter – Solaris 10 und 11.3

svcadm enable ipfilter	IP-Filter-Dienst starten (nur Solaris 10 / 11.3 und älter)
/etc/ipf/ipf.conf, ipnat.conf, ippool.conf	Regeldateien von IP Filter (nur Solaris 10 / 11.3)
ipf -Fa -f /etc/ipf/ipf.conf	Regeln neu laden (nur Solaris 10 / 11.3)
ipf -V	Version und Status des Filters (nur Solaris 10 / 11.3)
ipfstat -io	Aktive Ein- und Ausgangsregeln (nur Solaris 10 / 11.3)
ipfstat -hio	Regeln mit Trefferzählern (nur Solaris 10 / 11.3)
ipnat -l / ipnat -CF -f /etc/ipf/ipnat.conf	NAT-Regeln anzeigen / neu laden (nur Solaris 10 / 11.3)
ipmon -sD	IPF-Logmeldungen ins syslog schreiben (nur Solaris 10 / 11.3)

Weitere Absicherung

dladm set-linkprop -p protection=mac-nospoof,ip-nospoof vnic0	Link Protection: Spoofing durch Zonen verhindern
dladm set-linkprop -p allowed-ips=10.0.0.20 vnic0	VNIC auf bestimmte IP-Adressen festnageln
dladm show-linkprop -p protection,allowed-ips vnic0	Aktive Link-Protection prüfen
inetadm -M tcp_wrappers=TRUE	TCP Wrapper für alle inetd-Dienste einschalten
/etc/hosts.allow, /etc/hosts.deny	TCP-Wrapper-Regeln (auch von sshd genutzt)
svccfg -s svc:/network/ssh setprop …; /etc/ssh/sshd_config	SSH absichern (PermitRootLogin, Ciphers, AllowGroups)
ipsecconf -l / ipsecconf -a /etc/inet/ipsecinit.conf	IPsec-Policy anzeigen / laden
ipseckey -s / ikeadm dump p1	Security Associations bzw. IKE-Phase-1-Zustände prüfen
netstat -an -f inet \| grep LISTEN	Angriffsfläche prüfen: welche Ports sind offen?
svcs -a \| grep -e telnet -e rlogin -e ftp	Klartext-Dienste finden und mit `svcadm disable` abschalten

Versionsbruch: Solaris 11.4 ersetzt IP Filter durch das aus OpenBSD stammende Packet Filter. Alte ipf.conf-Regelwerke laufen nicht weiter – mit ipf2pf konvertieren und das Ergebnis von Hand prüfen.

Reihenfolge beim Aktivieren: Immer erst pfctl -n -f prüfen, dann per Konsole/ILOM (nicht per SSH!) aktivieren. Scheitert das Laden des Regelwerks, lädt der Dienst das Basis-Schutzregelwerk, das nur Port 22 durchlässt – alles andere ist dann blockiert.

📡NFS, SMB & Netzwerkdienste

NFS-Server

svcadm enable -r nfs/server	NFS-Server samt Abhängigkeiten starten
svcs -a \| grep nfs	Status aller NFS-Dienste (server, client, mapid, rquota, cbd)
zfs set share.nfs=on tank/data	Solaris 11.1+: ZFS-Dataset per NFS freigeben
zfs set share.nfs.sec.default.rw=@10.0.0.0/24 tank/data	Schreibzugriff auf ein Netz begrenzen
zfs set share.nfs.sec.default.root=@10.0.0.5 tank/data	Root-Zugriff für einen bestimmten Client erlauben
zfs get -r share.nfs tank	Alle NFS-Freigaben eines Pools prüfen
zfs set sharenfs=on tank/data	Ältere Syntax (Solaris 10 / 11.0), wird weiter unterstützt
share -F nfs -o rw=@10.0.0.0/24 /export/data	Nicht-ZFS-Verzeichnis temporär freigeben
share	Alle aktiven Freigaben mit Optionen anzeigen
unshare /export/data	Freigabe zurücknehmen
/etc/dfs/dfstab	Dauerhafte Freigaben (nur Solaris 10; in 11 über ZFS-Properties)
shareall / shareall -F nfs	Alle Einträge aus `dfstab` aktivieren (Solaris 10)
sharemgr show -vp	Share-Gruppen und Freigaben anzeigen (Solaris 10 / 11.0)
sharectl get nfs	Globale NFS-Parameter (Versionen, Ports, Grace-Zeiten)
sharectl set -p server_versmax=4 nfs	Maximale NFS-Version festlegen, danach Dienst neu starten
dfshares / dfshares sol02	Freigaben des lokalen bzw. eines entfernten Servers auflisten
dfmounts	Welche Clients haben welche Freigabe gemountet
nfsstat -s	Serverseitige NFS-Statistik

NFS-Client & Automounter

showmount -e sol02	Verfügbare Freigaben eines Servers anzeigen
mount -F nfs sol02:/export/data /mnt	Temporär mounten
mount -F nfs -o vers=3,rw,hard,intr sol02:/export/data /mnt	Mount mit typischen Optionen
mount -F nfs -o vers=4,rw,proto=tcp sol02:/export/data /mnt	NFSv4 explizit erzwingen
/etc/vfstab → sol02:/export/data - /data nfs - yes rw,hard,intr	Dauerhafter NFS-Mount (weiterhin über vfstab)
nfsstat -m	Pro Mount: ausgehandelte Version, Timeouts, Serverantwortzeiten
nfsstat -c	Clientseitige Statistik (Retransmits prüfen!)
rpcinfo -p sol02	RPC-Dienste des Servers prüfen (rpcbind, nfs, mountd)
/etc/auto_master, /etc/auto_home, /etc/auto_direct	Autofs-Konfiguration: Master-, Home- und Direct-Maps
automount -v	Autofs-Maps neu einlesen und Aktionen anzeigen
svcadm restart system/filesystem/autofs	Autofs-Dienst neu starten
sharectl get -p nfsmapid_domain nfs	NFSv4-Domain prüfen (falsche Domain → alles gehört `nobody`)

SMB/CIFS & weitere Dienste

pkg install service/file-system/smb	SMB-Serverpaket installieren
svcadm enable -r smb/server	SMB-Server starten
zfs set share.smb=on tank/daten	Dataset per SMB freigeben (Solaris 11.1+)
zfs set share.smb.name=Daten tank/daten	Sichtbaren Sharenamen festlegen
smbadm join -w ARBEITSGRUPPE	Server einer Workgroup beitreten lassen
smbadm join -u admin intern.example	In eine Active-Directory-Domain aufnehmen
smbadm list	Domain-/Workgroup-Zugehörigkeit und Domain-Controller
smbadm show-user / smbadm enable-user rene	SMB-Benutzer verwalten
sharectl get smb	Globale SMB-Parameter (Signing, Protokollversionen)
smbstat -r	SMB-Server: Sitzungen und Durchsatz
svcadm enable ntp; ntpq -p	Zeitsynchronisation starten und Peers prüfen
/etc/inet/ntp.conf	NTP-Konfiguration (Server, driftfile, restrict)
svcadm enable ptp	Solaris 11.4: Precision Time Protocol als Alternative zu NTP
date -u; TZ=Europe/Berlin date	UTC-Zeit bzw. Zeit in anderer Zone anzeigen
svccfg -s timezone:default setprop timezone/localtime = astring: Europe/Berlin	Zeitzone in Solaris 11 systemweit setzen
/etc/default/init → TZ=Europe/Berlin	Zeitzone in Solaris 10 setzen
svcadm enable sendmail / svcadm disable sendmail	Mailversand aktivieren/abschalten (`mailwrapper` für Postfix)
svcadm enable network/ssh; ssh-keygen -t ed25519	SSH-Dienst und Schlüsselpaar
scp -p datei user@sol02:/pfad/ ; sftp user@sol02	Dateitransfer mit Zeitstempel bzw. interaktiv

NFS-Freigabe prüfen: zfs get -r share.nfs tank → share → dfshares → auf dem Client showmount -e. Kommt nichts, zuerst svcs -xv auf dem Server – meist ist nfs/server offline, weil kein Share definiert ist.

NFSv4 und IDs: Bei NFSv4 werden Namen statt UIDs übertragen. Stimmen nfsmapid_domain auf Server und Client nicht überein, gehören alle Dateien nobody:nobody. Prüfen mit sharectl get nfs.

👤User, RBAC, Privilegien & ACLs

Benutzer & Gruppen

useradd -u 5001 -g staff -d /export/home/rene -m -s /usr/bin/bash rene	User anlegen samt Home-Verzeichnis
useradd -G dba,sysadmin -c "Rene Pfeifer" rene	Zusätzliche Gruppen und Kommentar
usermod -G staff,dba rene	Sekundäre Gruppen neu setzen (ersetzt die alte Liste!)
usermod -s /usr/bin/pfbash rene	Profil-Shell zuweisen (Voraussetzung für RBAC-Rechte)
usermod -K defaultpriv=basic,net_privaddr rene	Privilegien-Set eines Users erweitern
userdel -r rene	User samt Home-Verzeichnis löschen
passwd rene / passwd -r files rene	Passwort setzen, ggf. Namensdienst explizit angeben
passwd -l rene / passwd -u rene	Account sperren / entsperren
passwd -N rene	Login sperren, Cron-Jobs des Users laufen weiter
passwd -s rene	Passwort-Status und Alterungsdaten anzeigen
passwd -x 90 -w 14 -n 1 rene	Passwort-Alterung: max, Warnung, min Tage
passwd -f rene	Passwortwechsel beim nächsten Login erzwingen
groupadd -g 2001 dba / groupmod / groupdel dba	Gruppen verwalten
id / id -a rene / groups rene	UID, GID und Gruppen anzeigen
userattr type rene / userattr roles rene	Solaris 11: einzelne Attribute aus `user_attr` lesen
getent passwd rene; getent group dba	Auflösung über alle Namensdienste testen
logins -x -l rene / logins -p	Login-Details eines Users / alle Accounts ohne Passwort
who / w / last \| head -20	Angemeldete User / letzte Anmeldungen
/var/adm/wtmpx, /var/adm/lastlog	Login-Historie (mit `last` auswerten)
/etc/default/passwd	Systemweite Passwortregeln (MINLENGTH, HISTORY, Komplexität)
/etc/default/login	Root-Login auf Konsole, RETRIES, TIMEOUT
/etc/security/policy.conf	Standard-Rechtsprofile, Privilegien und Krypto-Algorithmus

RBAC: Rollen, Profile & Autorisierungen

profiles	Eigene Rechtsprofile anzeigen
profiles -l rene	Alle Profile eines Users mit den enthaltenen Kommandos
profiles -p "Netz Admin" info	Details eines Rechtsprofils
roles / roles rene	Welche Rollen darf der User annehmen?
auths / auths rene	Zugewiesene Autorisierungen (`solaris.*`)
roleadd -m -d /export/home/netadm -P "Network Management" netadm	Rolle mit Rechtsprofil anlegen
rolemod -P "Network Management,File System Management" netadm	Profile einer Rolle ändern
roledel -r netadm	Rolle entfernen
usermod -R netadm rene	Rolle einem User zuweisen
usermod -P "Software Installation" rene	Rechtsprofil direkt an den User hängen
usermod -A solaris.smf.manage.apache rene	Einzelne Autorisierung zuweisen
su - netadm	In eine Rolle wechseln (mit dem Rollenpasswort)
pfexec zpool status	Einzelnes Kommando mit den Rechten des Profils ausführen
pfbash / pfksh / pfsh	Profil-Shells: alle Kommandos laufen mit den Profilrechten
profiles -p "MyApp Admin" -S ldap 'set desc="…"; add cmd=/opt/app/bin/ctl; end'	Eigenes Rechtsprofil interaktiv anlegen
/etc/user_attr, /etc/user_attr.d/	Zuordnung User → Rollen/Profile (in 11 auch als Fragmentdateien)
/etc/security/prof_attr, /etc/security/exec_attr	Definition der Rechtsprofile und der darin erlaubten Kommandos
/etc/security/auth_attr	Alle bekannten Autorisierungen mit Beschreibung
visudo; sudo -l	sudo ist ebenfalls vorhanden – RBAC ist der Solaris-eigene Weg

Privilegien (Least Privilege)

ppriv -l	Alle im Kernel definierten Privilegien auflisten
ppriv -l -v net_privaddr	Beschreibung eines einzelnen Privilegs
ppriv $$	Privilegien-Sets der eigenen Shell (E, P, I, L)
ppriv -S <pid>	Privilegien eines laufenden Prozesses vereinfacht anzeigen
ppriv -eD cmd	Kommando starten und protokollieren, welche Privilegien fehlen
ppriv -s A-net_rawaccess -e cmd	Kommando mit reduzierten Privilegien starten
svccfg -s myapp setprop start/privileges = astring: basic,net_privaddr	Dienst mit minimalen Privilegien laufen lassen

ZFS-ACLs & Dateirechte

chmod 750 datei; chown user:group datei	Klassische POSIX-Rechte
umask 022	Standardrechte für neue Dateien
ls -v datei	ZFS-ACL im ausführlichen Format anzeigen
ls -V datei	ZFS-ACL kompakt anzeigen
chmod A+user:rene:rwx:allow datei	ACL-Eintrag hinzufügen
chmod A+group:dba:read_data/write_data:allow datei	Feingranulare Rechte für eine Gruppe
chmod A0- datei	Ersten ACL-Eintrag (Index 0) löschen
chmod A- datei	Alle nicht-trivialen ACL-Einträge entfernen
chmod -R A+user:rene:rwx:fd:allow /data	Rekursiv mit Vererbung auf Dateien und Verzeichnisse
zfs set aclinherit=passthrough tank/data	Vererbungsverhalten der ACLs steuern
zfs set aclmode=passthrough tank/data	Verhalten von `chmod` auf vorhandene ACLs

Auditing, BART & Compliance

auditconfig -getpolicy / -getflags	Audit-Policy und aktive Klassen anzeigen
auditconfig -setflags lo,ad,ex	Audit-Klassen setzen (Logins, Administration, exec)
auditreduce -d 20260818 \| praudit -x \| more	Audit-Trail eines Tages filtern und lesbar ausgeben
audit -s / audit -n	Audit-Konfiguration neu laden / Logdatei rotieren
svcadm enable auditd; svcs auditd	Audit-Dienst aktivieren und prüfen
bart create -R / > /var/tmp/bart_$(date +%F).manifest	Datei-Fingerprint des Systems erzeugen
bart create -r /etc/bart/rules > manifest.neu	Nur definierte Bereiche erfassen
bart compare manifest.alt manifest.neu	Welche Dateien haben sich geändert? (Change-Nachweis)
compliance list -p	Verfügbare Compliance-Benchmarks und Profile (ab 11.2)
compliance assess -b solaris -p Baseline	Bewertung gegen die Solaris-Security-Baseline durchführen
compliance list -a	Bereits durchgeführte Assessments auflisten
compliance report -a <assessment> -f /var/tmp/report.html	HTML-Bericht erzeugen (Audit-taugliche Dokumentation)
/etc/pam.conf, /etc/pam.d/	PAM-Stacks (in 11.4 aufgeteilt nach Diensten)

RBAC statt sudo-Wildwuchs: Eine Rolle anlegen (roleadd -P "…"), dem Admin zuweisen (usermod -R) und die Profil-Shell setzen. Der Admin arbeitet dann ohne root-Passwort, jede Aktion ist über den Audit-Trail nachvollziehbar.

Immutable Zones: Mit zonecfg -z z1 set file-mac-profile=fixed-configuration wird die Zone read-only – nicht einmal root in der Zone kann Systemdateien ändern. Werte: none, strict, fixed-configuration, flexible-configuration.

🧮Zonen, Kernel Zones & LDoms

Zonen verwalten

zoneadm list -cv	Alle konfigurierten Zonen mit ID, Status, Pfad, Brand und IP-Typ
zoneadm list -iv	Nur installierte bzw. laufende Zonen
zonename; zoneadm list -p	Eigene Zone / maschinenlesbare Liste
zonecfg -z z1 info	Komplette Konfiguration einer Zone anzeigen
zonecfg -z z1 export > /var/tmp/z1.cfg	Konfiguration sichern bzw. auf anderen Host übertragen
zonecfg -z z1 -f /var/tmp/z1.cfg	Zone aus einer Konfigurationsdatei erzeugen
zonecfg -z z1	Interaktiv konfigurieren (`create`, `set`, `add`, `verify`, `commit`)
zoneadm -z z1 verify	Konfiguration auf Plausibilität prüfen, ohne zu installieren
zoneadm -z z1 install	Zone installieren (IPS holt die Pakete vom Publisher)
zoneadm -z z1 install -c /var/tmp/z1-profile.xml	Mit vorbereitetem System-Configuration-Profil (unattended)
zoneadm -z z1 boot / halt / reboot	Zone starten / hart stoppen / neu starten
zoneadm -z z1 shutdown	Zone sauber herunterfahren (Dienste werden gestoppt)
zlogin -C z1	An die Zonenkonsole (Erstkonfiguration); Lösen mit `~.`
zlogin z1 / zlogin z1 svcs -xv	Shell in der Zone / einzelnes Kommando ausführen
zoneadm -z z1 detach / attach	Zone abmelden bzw. auf anderem Host anmelden (Umzug)
zoneadm -z z1 attach -u	Beim Anhängen an den Paketstand des neuen Hosts anpassen
zoneadm -z z2 clone z1	Zone klonen (ZFS-Klon, in Sekunden fertig)
zoneadm -z z1 uninstall -F	Zone deinstallieren, Konfiguration bleibt erhalten
zonecfg -z z1 delete -F	Zonenkonfiguration endgültig entfernen
zoneadm -z z1 move /zones_neu/z1	Zonepath verschieben
zonestat -z z1 5	Ressourcenverbrauch einer Zone live beobachten
zonep2vchk -b	Physisches System auf Zonen-Tauglichkeit prüfen (P2V-Vorbereitung)
/etc/zones/index, /etc/zones/z1.xml	Zonenregister und -konfiguration auf dem Global-Zone-Dateisystem

Typische zonecfg-Bausteine

create; set zonepath=/zones/z1; set autoboot=true	Grundgerüst einer Solaris-Zone
add anet; set lower-link=net0; end	Automatische VNIC (Exclusive-IP) – Standard in Solaris 11
add anet; set lower-link=net0; set allowed-address=10.0.0.21/24; end	Zone auf eine feste IP festlegen
add net; set physical=net1; set address=10.0.0.22/24; end	Shared-IP-Variante (klassisch, auch Solaris 10)
add dataset; set name=tank/zonedata; end	ZFS-Dataset an die Zone delegieren
add fs; set dir=/opt/app; set special=/export/app; set type=lofs; end	Verzeichnis der Global Zone einbinden
add capped-memory; set physical=8g; set swap=16g; end	Speicher begrenzen
set cpu-shares=200 / add capped-cpu; set ncpus=4; end	CPU-Anteil bzw. harte CPU-Grenze
add dedicated-cpu; set ncpus=2-4; end	Eigenen Prozessorpool zuweisen
create -t SYSsolaris-kz	Kernel Zone: eigener Kernel, unabhängig aktualisierbar
create -t SYSsolaris10	Solaris-10-Branded Zone (Migration alter S10-Systeme)
set file-mac-profile=fixed-configuration	Immutable Zone (read-only Root)
set limitpriv=default,dtrace_proc,dtrace_user	Zusätzliche Privilegien in der Zone erlauben

LDoms / Oracle VM Server for SPARC

virtinfo -a	Rolle des Systems: Control Domain, Guest Domain, Kernel Zone?
svcadm enable ldmd; ldm list	LDom-Manager starten und alle Domains auflisten
ldm list -l primary	Vollständige Konfiguration einer Domain
ldm list -o network,disk dom1	Nur bestimmte Bereiche der Konfiguration anzeigen
ldm list-bindings	Welche Ressourcen sind welcher Domain fest zugeordnet
ldm list-devices -a	Alle freien und belegten Ressourcen der Plattform
ldm list-services	Virtuelle Dienste: vsw, vds, vcc (Konsolen-Konzentrator)
ldm add-domain dom1	Neue Guest Domain anlegen
ldm add-vcpu 16 dom1 / ldm remove-vcpu 8 dom1	vCPUs dynamisch hinzufügen/entziehen
ldm set-memory 32g dom1	Speicher der Domain setzen
ldm add-vdsdev /dev/zvol/dsk/tank/dom1 vol1@primary-vds0	Backend-Device im Virtual Disk Service bereitstellen
ldm add-vdisk vdisk0 vol1@primary-vds0 dom1	Virtuelle Platte der Domain zuweisen
ldm add-vnet vnet0 primary-vsw0 dom1	Virtuelles Netzwerk anbinden
ldm bind dom1; ldm start dom1	Ressourcen binden und Domain starten
ldm stop dom1; ldm unbind dom1	Domain stoppen und Ressourcen freigeben
telnet localhost 5000	Auf die virtuelle Konsole einer Domain (Port aus `ldm list`)
ldm add-spconfig prod-2026-08	Konfiguration im Service Processor sichern – sonst nach Power-Cycle weg!
ldm list-spconfig	Gespeicherte Konfigurationen und die aktive anzeigen
ldm set-spconfig prod-2026-08	Konfiguration für den nächsten Plattform-Neustart wählen
ldm migrate-domain dom1 root@sparc02	Live-Migration auf einen anderen SPARC-Server

LDom-Klassiker: Nach jeder Änderung an der Domain-Konfiguration ldm add-spconfig ausführen. Ohne gesicherte Konfiguration bootet die Plattform nach einem Power-Cycle in die factory-default-Konfiguration – alle Guest Domains sind dann verschwunden.

Zone vs. Kernel Zone: Normale Zonen teilen den Kernel der Global Zone und werden mit ihr aktualisiert – sparsam und schnell. Kernel Zones haben einen eigenen Kernel, lassen sich unabhängig patchen und live migrieren, kosten aber mehr Ressourcen.

🚨Fehleranalyse, FMA & Logs

Erste Diagnoseschritte

svcs -xv	Welche Dienste sind kaputt und warum – immer als Erstes
zpool status -x	Sind alle Pools gesund?
fmadm faulty	Von der FMA diagnostizierte Defekte mit UUID und FRU
fmadm faulty -a	Auch bereits behobene bzw. quittierte Diagnosen
fmadm repaired <fmri\|uuid>	Nach dem Hardwaretausch als repariert markieren
fmadm acquit <uuid>	Fehldiagnose freisprechen (Bauteil war doch in Ordnung)
fmadm config	Geladene Diagnose-Module der FMA
fmdump	Fault-Log: alle abgeschlossenen Diagnosen mit Zeitstempel
fmdump -eV \| more	Rohe Fehler-Events mit allen Details (ereport-Payload)
fmdump -eV -t "18Aug2026 08:00"	Events ab einem Zeitpunkt einschränken
fmdump -Vu <uuid>	Alle Events zu einer konkreten Diagnose
fmstat	Statistik je Diagnose-Modul (welches Modul feuert?)
prtdiag -v	Hardwarestatus inkl. der Abschnitte Failed und Environmental
iostat -En \| grep -v "0 Hard"	Nur Platten mit Fehlerzählern > 0 anzeigen
dmesg \| tail -50	Letzte Kernelmeldungen (liest aus `/var/adm/messages`)
svcs -Lv <fmri> \| tail -40	Logdatei des betroffenen Dienstes direkt lesen

Logs

/var/adm/messages	Zentrales Systemlog (Kernel, Treiber, Dienste)
tail -f /var/adm/messages	Live mitlesen – parallel zur Fehlerreproduktion
/var/adm/messages.0 … .3	Von `logadm` rotierte ältere Logs
/etc/syslog.conf	Wohin schreibt syslogd welche Facility/Level
svcadm refresh system-log	syslog.conf neu einlesen
svcs -a \| grep system-log	11.4: Instanzen `:default` (syslogd) und `:rsyslog`
pkg install rsyslog; svcadm enable system-log:rsyslog	11.4: rsyslog als Alternative aktivieren (nur eine Instanz online!)
logadm -V	Alle Rotationsregeln aus `/etc/logadm.conf` prüfen
logadm -w myapp -C 8 -c -p 1d /var/log/myapp/app.log	Eigene Rotationsregel anlegen (8 Generationen, täglich)
logadm -p now myapp	Rotation sofort auslösen (zum Testen)
/var/svc/log/	Logdateien aller SMF-Dienste
/var/log/syslog, /var/log/authlog	Mail- bzw. Authentifizierungsmeldungen
/var/adm/utmpx, /var/adm/wtmpx	Aktuelle und historische Logins (binär, mit `who`/`last`)
/var/log/zones/	Konsolen- und Installationslogs der Zonen

Kernel-Debugger & Support-Daten

mdb -k	Kernel-Debugger am laufenden System (Ausstieg mit `::quit`)
mdb -k -e "::status"	Kurzstatus: Release, Plattform, Panic-Zustand
mdb 1 (in /var/crash)	Crash-Dump Öffnen (`unix.1` + `vmcore.1`)
> ::status	Überblick zum geladenen Dump
> ::panicinfo	Panic-Meldung, Register und auslösender Thread
> ::msgbuf	Kernel-Meldungspuffer zum Zeitpunkt des Absturzes
> ::stack / ::threadlist -v	Aktueller Stack bzw. alle Threads mit Stacks
> ::ps / ::pgrep java	Prozessliste im Dump / gezielt suchen
> ::memstat	Speicherverteilung (Kernel, ZFS-ARC, Anon, Page Cache, Free)
> ::kmastat	Kernel-Memory-Allocator-Statistik (Leak-Suche)
> ::arc	ZFS-ARC-Details im Dump
explorer	Oracle Explorer (Services Tools Bundle): komplette Supportdatensammlung
explorer -w default,zfs,net	Nur bestimmte Module sammeln
/var/explorer/output/	Ergebnisarchiv des Explorer für den Oracle-Support
/usr/lib/scrub/…; prtdiag -v; showrev -a	Ergänzende Systemdaten für den Support-Call

Standard-Diagnosekette: svcs -xv → fmadm faulty → zpool status -x → tail -100 /var/adm/messages → iostat -En → prtdiag -v. Damit sind die meisten Störungen in fünf Minuten eingegrenzt.

Vor dem Oracle-Support-Call: explorer laufen lassen, dazu cat /etc/release, pkg info entire, den passenden Dump aus /var/crash und die Ausgabe von fmdump -eV bereithalten.

💾Backup, Recovery & Installation

ZFS als Backup-Standard

zfs snapshot -r tank@$(date +%Y%m%d-%H%M)	Konsistenter Snapshot des ganzen Baums als Backup-Basis
zfs send -R tank/data@voll \| ssh sol02 zfs recv -Fdu tank2	Vollreplikation auf einen zweiten Server
zfs send -i @gestern tank/data@heute \| ssh sol02 zfs recv tank2/data	Tägliches Inkrement – nur die geänderten Blöcke gehen übers Netz
zfs send -R tank/data@snap \| gzip > /backup/data_$(date +%F).zfs.gz	Stream als Datei archivieren (z. B. auf NFS-Share)
gunzip -c /backup/data.zfs.gz \| zfs recv -F tank/data	Aus dem Stream zurückspielen
zfs list -t snapshot -o name,creation -r tank \| tail	Snapshot-Kette und Aufbewahrung kontrollieren
zfs destroy tank/data@alt1%alt7	Alte Snapshots einer Generation aufräumen
beadm create pre-change-$(date +%F)	Systemseitiges Rollback vor jedem Change
zpool status rpool; bootadm install-bootloader -P rpool	Root-Pool-Spiegel prüfen und Bootloader auf alle Platten schreiben

Klassische Werkzeuge

tar cvf /backup/etc.tar /etc	tar-Archiv (`xvf` entpacken, `tvf` listen)
tar cvEf /backup/data.tar /data	Mit erweiterten Attributen/ACLs sichern
find /data -depth -print \| cpio -ocv > /backup/data.cpio	cpio-Sicherung
cpio -icvdm < /backup/data.cpio	cpio-Restore mit Verzeichnisstruktur
find . -depth -print \| cpio -pdumv /ziel	Verzeichnisbaum rechtetreu kopieren
pax -rw -pe /data /backup/data	pax: kopieren mit Erhalt aller Attribute
dd if=/dev/rdsk/c1t0d0s0 of=/backup/s0.dd bs=1024k	Raw-Kopie einer Partition
rsync -avz --delete /data/ sol02:/data/	Inkrementell synchronisieren (Paket `network/rsync`)
mt -f /dev/rmt/0n status / rewind / fsf 1	Bandlaufwerk steuern (`n` = no rewind)
ufsdump 0uf /dev/rmt/0 /data	UFS-Vollsicherung (nur für UFS-Altbestände)
flarcreate -n sol10img -c /export/sol10.flar	Flash-Archive des ganzen Systems (nur Solaris 10)
flar info /export/sol10.flar	Inhalt eines Flash-Archivs prüfen (nur Solaris 10)

Installation & Notfall-Recovery

installadm create-service -n s11-4-sparc -s /repo/sol-11_4-ai.iso	Automated-Installer-Service anlegen (Solaris 11)
installadm list -m -p	AI-Services, Manifeste und Profile auflisten
installadm create-client -e 00:14:4f:aa:bb:cc -n s11-4-sparc	Client per MAC-Adresse an einen AI-Service binden
installadm create-manifest -n s11-4-sparc -f manifest.xml	Eigenes AI-Manifest hinterlegen
sysconfig create-profile -o /var/tmp/sc.xml	System-Configuration-Profil interaktiv erzeugen
sysconfig unconfigure -g system	System für Klonen/Auslieferung zurücksetzen (ersetzt `sys-unconfig`)
sys-unconfig	Systemidentität zurücksetzen (nur Solaris 10)
setup_install_server / add_install_client	JumpStart-Installationsserver (nur Solaris 10)
ok> boot cdrom -s (bzw. AI-Media, Option "Shell")	Rettungsboot in die Wartungsumgebung
zpool import -f -R /a rpool	Root-Pool von außen importieren
beadm list -a; zfs mount rpool/ROOT/solaris	BE finden und einhängen, Konfiguration reparieren
bootadm update-archive -R /a; bootadm install-bootloader -R /a -P rpool	Boot-Archiv und Bootloader des Alt-Systems reparieren
zpool export rpool; reboot	Nach der Reparatur sauber exportieren und neu starten
zpool import -f tank	Datenpool nach Systemtausch übernehmen (Hostid weicht ab)
zpool import -D -f tank	Versehentlich zerstörten Pool wiederherstellen

Backup-Routine Solaris 11: Stündlich/täglich zfs snapshot -r, täglich zfs send -i auf einen zweiten Server, wöchentlich ein zfs send -R-Vollstream aufs Band/NFS, vor jedem Change beadm create. Restore mindestens einmal jährlich testen – ein ungetestetes Backup ist kein Backup.

Snapshot ist kein Backup: Snapshots liegen im gleichen Pool. Geht der Pool verloren, sind sie mit weg. Erst die Replikation per zfs send auf ein zweites System macht daraus ein Backup.

📄Wichtige Dateien & Verzeichnisse

/etc/release	Genaue OS-Version – erste Datei bei jeder Analyse
/etc/vfstab	Mount-Tabelle; in Solaris 11 nur noch UFS, Swap, NFS, legacy-ZFS
/etc/mnttab	Tatsächlich gemountete Dateisysteme (Kernel, read-only)
/etc/dfs/dfstab, /etc/dfs/sharetab	NFS-Freigaben (dfstab nur Solaris 10) bzw. aktive Shares
/etc/inet/hosts, /etc/inet/ipnodes	Lokale Namensauflösung (`/etc/hosts` ist ein Symlink)
/etc/resolv.conf, /etc/nsswitch.conf	DNS und Reihenfolge der Namensquellen (in 11 aus SMF generiert)
/etc/hostname.<if>, /etc/defaultrouter	Netzkonfiguration (nur Solaris 10)
/etc/inet/ntp.conf	Zeitsynchronisation
/etc/system	Kernel-Parameter beim Boot – in 11 nur noch selten nötig
/etc/default/init	Systemweite Defaults wie `TZ`, `LANG` (Solaris 10 Zeitzone)
/etc/default/passwd, /etc/default/login, /etc/default/su	Passwortregeln, Login-Verhalten, su-Protokollierung
/etc/security/policy.conf	Standardprofile, Privilegien und Krypto-Verfahren
/etc/user_attr, /etc/security/prof_attr, exec_attr, auth_attr	RBAC-Datenbanken
/etc/profile, /etc/skel/	Login-Umgebung für alle User bzw. Vorlagen für neue Homes
/etc/motd, /etc/issue	Begrüßungstext nach bzw. vor dem Login
/etc/logadm.conf	Regeln der Logrotation
/etc/syslog.conf	Ziele der syslog-Meldungen
/etc/zones/, /etc/zones/index	Zonenkonfigurationen und -register
/etc/firewall/pf.conf	Firewall-Regelwerk (Solaris 11.4)
/etc/ipf/ipf.conf	IP-Filter-Regeln (Solaris 10 / 11.3)
/etc/driver/drv/*.conf	Treiberparameter in Solaris 11 (in 10: `/kernel/drv/`)
/etc/lvm/md.tab, /etc/lvm/mddb.cf	SVM-Konfiguration (Altbestand)
/etc/auto_master, /etc/auto_home	Automounter-Maps
/var/adm/messages	Zentrales Systemlog
/var/svc/log/, /var/svc/manifest/	SMF-Logs bzw. Site-Manifeste
/lib/svc/manifest/, /lib/svc/method/	Von Paketen gelieferte SMF-Manifeste und -Methoden
/var/spool/cron/crontabs/	Crontabs aller User
/var/crash/	Ausgewertete Crash-Dumps
/var/sadm/pkg/, /var/sadm/patch/	SVR4-Paket- und Patch-Datenbank (Solaris 10)
/var/pkg/	IPS-Metadaten und Publisher-Kataloge (Solaris 11)
/dev/dsk/, /dev/rdsk/	Block- bzw. Raw-Devices der Platten
/dev/zvol/dsk/rpool/…	ZFS-Volumes (Swap, Dump, LDom-Backends)
/dev/rmt/0, /dev/rmt/0n	Bandlaufwerk mit / ohne automatisches Zurückspulen
/devices/, /dev/cfg/	Physischer Gerätebaum bzw. Controller-Links

Standard-Datasets im rpool

rpool/ROOT	Container aller Boot Environments
rpool/ROOT/solaris	Aktives Boot Environment (Root-Dateisystem)
rpool/ROOT/solaris/var	Eigenes Dataset für `/var` je BE
rpool/VARSHARE	BE-übergreifend gemeinsame Teile von `/var` (z. B. `/var/mail`)
rpool/export, rpool/export/home	Home-Verzeichnisse
rpool/swap, rpool/dump	Swap- und Dump-Volumes

🔧Shell-Tipps & Praxis-Workflows

Shell & Werkzeuge

echo $SHELL; pkg list shell/bash	Standard-Shell in Solaris 11 ist bash, in 10 ksh/sh
set -o vi	vi-Editiermodus in ksh/bash (Esc + `k` für History)
which cmd / whence -v cmd / type cmd	Pfad und Typ eines Kommandos
man -k begriff / man -s 8 zfs	Manpages durchsuchen / gezielte Sektion (11.4: 8 statt 1M)
PATH=/usr/gnu/bin:$PATH	GNU-Varianten der Standardwerkzeuge nutzen (Solaris 11)
/usr/xpg4/bin/grep -E, /usr/xpg6/bin/	POSIX-konforme Varianten – wichtig bei portablen Skripten
nawk '{print $1,$5}' datei	Auf Solaris ist `nawk` die brauchbare awk-Variante
sed -e 's/alt/neu/g' datei > neu.txt	Textersetzung
for p in $(zpool list -H -o name); do zpool status -x $p; done	Schleife über alle Pools
zoneadm list -p \| cut -d: -f2	Alle Zonennamen skriptfreundlich extrahieren
script /var/tmp/session_$(date +%F).log	Terminalsitzung protokollieren (Change-Nachweis)
tee -a /var/tmp/log	Ausgabe anzeigen und gleichzeitig mitschreiben
nohup ./skript.sh > /var/tmp/out 2>&1 &	Langlaufende Skripte abgekoppelt starten
df -h; du -sk /var/* \| sort -rn \| head -20	Platzverbrauch eingrenzen
find /var -xdev -size +100000c -ls \| sort -k7 -rn \| head	Große Dateien ohne Mount-Grenzen zu überschreiten
digest -a sha256 datei; elfdump -d /usr/bin/ls	Checksumme bilden / ELF-Abhängigkeiten prüfen
isaexec, ldd /usr/bin/ls	Bibliotheksabhängigkeiten eines Programms

Workflow: Neue LUN einbinden und ZFS-Pool erweitern

# 1) LUN im Storage zonen/mappen, dann auf dem Host sichtbar machen
cfgadm -al                                  # Attachment Points pruefen
cfgadm -c configure c3                      # ggf. Controller konfigurieren
devfsadm -Cv                                # Geraetebaum aktualisieren
echo | format                               # neue Platte identifizieren
mpathadm list lu                            # alle Pfade aktiv? Operational Path Count
luxadm display /dev/rdsk/c0t60060160…d0s2  # Pfaddetails pruefen

# 2) In den Pool aufnehmen - Redundanz beibehalten!
zpool status tank
zpool add tank mirror c0t60060160AAd0 c0t60060160BBd0
zpool list tank && zpool status -v tank

# 3) Vorhandene LUN wurde nur vergroessert
zpool set autoexpand=on tank
zpool online -e tank c0t60060160AAd0        # falls autoexpand nachtraeglich
zpool list tank                             # SIZE muss gewachsen sein

Workflow: Update mit Boot Environment (der sichere Weg)

pkg publisher                               # zeigt der Publisher aufs richtige Repo?
pkg update -nv                              # Planung ansehen, NICHTS aendern
zpool list rpool                            # genug Platz fuer ein weiteres BE?
beadm list                                  # alte BEs ggf. aufraeumen

pkg update --be-name s11.4-sru42 --accept   # Update in ein neues BE
beadm list                                  # neues BE hat Flag "R" (reboot)
init 6

# --- nach dem Reboot ---
cat /etc/release; pkg info entire           # neuer Stand?
svcs -xv                                    # alle Dienste sauber?
zpool status -x; ipadm show-addr

# --- Rollback, falls etwas nicht laeuft ---
beadm list                                  # altes BE heraussuchen
beadm activate solaris                      # altes BE reaktivieren
init 6                                      # nach Reboot ist alles wie vorher
beadm destroy -F s11.4-sru42                # spaeter aufraeumen

Workflow: Dienst hängt oder startet nicht

svcs -xv                                    # welcher Dienst, welche Ursache?
svcs -l svc:/network/http:apache24          # Zustand, Restarter, Dependencies
svcs -d svc:/network/http:apache24          # fehlt eine Abhaengigkeit?
svcs -Lv svc:/network/http:apache24 | tail -40   # Logdatei lesen

# Ursache beheben (Config, Port belegt, Dateirechte, Filesystem voll)
netstat -an -f inet | grep LISTEN
svcprop -p start/exec svc:/network/http:apache24  # was wird ueberhaupt gestartet?

svcadm clear svc:/network/http:apache24      # aus maintenance holen
svcs -x svc:/network/http:apache24           # Kontrolle

# Wenn der Dienst danach weiter faellt:
svcadm disable -s svc:/network/http:apache24
svcadm enable  -s svc:/network/http:apache24
tail -f /var/svc/log/network-http:apache24.log

Workflow: Netzwerk dauerhaft konfigurieren (mit Aggregation)

# Ausgangslage pruefen
dladm show-phys
dladm show-link
ipadm show-if; ipadm show-addr

# LACP-Aggregation aus zwei Ports bauen
ipadm delete-ip net0 2>/dev/null            # Link muss frei von IP sein
ipadm delete-ip net1 2>/dev/null
dladm create-aggr -P L2,L3 -L active -l net0 -l net1 aggr0
dladm show-aggr -x                          # LACP auf beiden Ports "active"?
dladm set-linkprop -p mtu=9000 aggr0        # optional Jumbo Frames

# IP persistent vergeben
ipadm create-ip aggr0
ipadm create-addr -T static -a local=10.0.0.10/24 aggr0/v4
ipadm set-ifprop -p mtu=9000 -m ipv4 aggr0  # MTU auch auf IP-Ebene!
route -p add default 10.0.0.1               # -p = ueber Reboot hinaus

# DNS im SMF hinterlegen
svccfg -s dns/client setprop config/nameserver = net_address: "(10.0.0.53)"
svccfg -s dns/client setprop config/search    = astring: "(intern.example)"
svcadm refresh dns/client; svcadm restart name-service/cache

# Kontrolle
ipadm show-addr; netstat -rn; getent hosts sol02; ping -s 10.0.0.1 56 3

Workflow: Zone anlegen und starten

zfs create -o mountpoint=/zones rpool/zones
chmod 700 /zones

zonecfg -z web01 <<'EOF'
create
set zonepath=/zones/web01
set autoboot=true
add anet
  set lower-link=net0
  set allowed-address=10.0.0.21/24
  set defrouter=10.0.0.1
end
add capped-memory
  set physical=8g
  set swap=16g
end
set cpu-shares=200
verify
commit
EOF

zoneadm -z web01 verify
zoneadm -z web01 install                     # holt Pakete vom IPS-Publisher
zoneadm -z web01 boot
zlogin -C web01                              # Erstkonfiguration, Loesen mit ~.
zoneadm list -cv; zonestat -z web01 5

Workflow: ZFS-Backup per send/recv auf zweiten Server

# Einmalig: Vollreplikation
zfs snapshot -r tank/data@voll-$(date +%F)
zfs send -R tank/data@voll-2026-08-18 | \
    ssh root@sol02 zfs recv -Fdu tank2
ssh root@sol02 "zfs list -r tank2/data"

# Taeglich: Inkrement gegen den letzten uebertragenen Snapshot
LAST=$(ssh root@sol02 "zfs list -H -o name -t snapshot -r tank2/data | tail -1")
echo "Ziel steht auf: $LAST"
zfs snapshot -r tank/data@$(date +%F)
zfs send -i tank/data@2026-08-17 tank/data@2026-08-18 | \
    ssh root@sol02 zfs recv -u tank2/data

# Kontrolle und Aufraeumen
zfs list -t snapshot -o name,used,creation -r tank/data | tail
zfs destroy -n -v -r tank/data@2026-08-01    # erst Testlauf lesen!
zfs destroy -r tank/data@2026-08-01

Merksatz Solaris 11: Konfiguration lebt in drei Datenbanken – SMF (Dienste, Hostname, DNS), ZFS-Properties (Mounts, Shares, Quotas) und ipadm/dladm (Netz). Klassische Dateien wie /etc/vfstab oder /etc/dfs/dfstab sind nur noch Randfälle. Wer die Datei editiert statt das Kommando zu nutzen, verliert die Änderung beim nächsten Refresh.

Change-Vorbereitung (Standard): cat /etc/release, pkg info entire, svcs -xv, zpool status -x, ipadm show-addr, netstat -rn, df -h in eine Datei sichern – danach beadm create. Erst dann anfangen.