Schulungsübersicht

Einführung

  • Ziele
  • Wer Sie sind
  • Die Linux Stiftung
  • Linux Foundation-Schulung
  • Zertifizierungsprogramme und Digital Badging
  • Linux Distributionen
  • Plattformen
  • Ihr System vorbereiten
  • Verwenden und Herunterladen einer virtuellen Maschine
  • Dinge ändern sich in Linux

Präliminarien

  • Abläufe
  • Standards und der LSB

Wie man in OSS-Projekten arbeitet **

  • Überblick über das richtige Beitragen
  • Für Sicherheit und Qualität nahe an der Mainline bleiben
  • Studieren und Verstehen der Projekt-DNA
  • Finden Sie heraus, was Sie tun wollen Scratch
  • Identifizieren Sie Maintainer und deren Arbeitsabläufe und Methoden
  • Frühzeitigen Input erhalten und offen arbeiten
  • Tragen Sie inkrementelle Bits bei, keine großen Code-Dumps
  • Lassen Sie Ihr Ego an der Tür: Seien Sie nicht dünnhäutig
  • Seien Sie geduldig, entwickeln Sie langfristige Beziehungen, seien Sie hilfsbereit

Kompilierer

  • GCC
  • Andere Compiler
  • Wichtige gcc-Optionen
  • Präprozessor
  • Integrierte Entwicklungsumgebungen (IDE)
  • Laboratorien

Bibliotheken

  • Statische Bibliotheken
  • Gemeinsame Bibliotheken
  • Verknüpfung mit Bibliotheken
  • Dynamischer Linking Loader
  • Laboratorien

Make

  • Verwendung von make und Makefiles
  • Große Projekte bauen
  • Kompliziertere Regeln
  • Eingebaute Regeln
  • Laboratorien

Quellcode-Kontrolle

  • Quellcode-Kontrolle
  • RCS und CVS
  • Unterversion
  • git
  • Laboratorien

Fehlersuche und Kerndumps

  • gdb
  • Was sind Core-Dump-Dateien?
  • Erzeugen von Core Dumps
  • Untersuchen von Core Dumps
  • Laboratorien

Debugging-Werkzeuge

  • Die Zeit ermitteln
  • Profiling und Leistung
  • valgrind
  • Laboratorien

Systemaufrufe

  • Systemaufrufe vs. Bibliotheksfunktionen
  • Wie Systemaufrufe gemacht werden
  • Rückgabewerte und Fehlernummern
  • Laboratorien

Speicher Management und Zuweisung

  • Speicher Management
  • Dynamische Zuweisung
  • Abstimmung von malloc()
  • Seiten sperren
  • Laboratorien

Dateien und Dateisysteme in Linux **

  • Dateien, Verzeichnisse und Geräte
  • Das virtuelle Dateisystem
  • Das ext2/ext3-Dateisystem
  • Journaling-Dateisysteme
  • Das ext4/-Dateisystem
  • Laboratorien

Datei-E/A

  • UNIX-Datei-E/A
  • Öffnen und Schließen
  • Lesen, Schreiben und Suchen
  • Positionale und vektorielle E/A
  • Standard-E/A-Bibliothek
  • Unterstützung großer Dateien (LFS)
  • Laboratorien

Erweiterte Dateioperationen

  • Stat-Funktionen
  • Verzeichnis-Funktionen
  • inotify
  • Speicher Mapping
  • flock() und fcntl()
  • Temporäre Dateien erstellen
  • Andere Systemaufrufe
  • Laboratorien

Prozesse I

  • Was ist ein Prozess?
  • Prozess-Grenzen
  • Prozess-Gruppen
  • Das proc-Dateisystem
  • InterProzess Communication Methoden
  • Laboratorien

Prozesse II

  • system() zum Erzeugen eines Prozesses verwenden
  • Mit fork() einen Prozess erzeugen
  • Mit exec() einen Prozess erstellen
  • Verwendung von clone()
  • Beenden von
  • Konstruktoren und Destruktoren
  • Wartende
  • Daemon-Prozesse
  • Laboratorien

Pipes und Fifos

  • Pipes und InterProzess Communication
  • popen() und pclose()
  • pipe()
  • Benannte Pipes (FIFOs)
  • splice(), vmsplice() und tee()
  • Laboratorien

Asynchrone E/A**

  • Was ist asynchrone E/A?
  • Die POSIX Asynchronous I/O API
  • Linux Implementierung
  • Laboratorien

Signale I

  • Was sind Signale?
  • Verfügbare Signale
  • Senden von Signalen
  • Alarme, Pausieren und Schlafen
  • Einrichten eines Signal-Handlers
  • Signal-Sets
  • sigaction()
  • Laboratorien

Signale II

  • Wiederholbarkeit und Signal-Handler
  • Springen und nicht-lokale Rückgaben
  • siginfo und sigqueue()
  • Echtzeit-Signale
  • Laboratorien

POSIX-Threads I

  • Multithreading unter Linux
  • Grundlegende Programmstruktur
  • Erstellen und Zerstören von Threads
  • Signale und Threads
  • Forking vs. Threading
  • Laboratorien

POSIX-Threads II

  • Deadlocks und Race Conditions
  • Mutex-Operationen
  • Semaphoren
  • Futexe
  • Bedingte Operationen
  • Laboratorien

Networking und Sockets

  • Networking Schichten
  • Was sind Sockets?
  • Stream-Sockel
  • Datagramm-Sockel
  • Rohe Sockets
  • Byte-Anordnung
  • Laboratorien

Socket-Adressen und Hosts

  • Socket-Adress-Strukturen
  • Konvertierung von IP-Adressen
  • Host-Informationen
  • Laboratorien

Sockets Ports und Protokolle

  • Informationen zum Dienstanschluss
  • Protokoll-Informationen
  • Laboratorien

Sockets Klienten

  • Grundlegende Client-Reihenfolge
  • Socket()
  • verbinden()
  • close() und shutdown()
  • UNIX-Klient
  • Internet-Klient
  • Laboratorien

Sockets Server

  • Grundlegende Server-Reihenfolge
  • binden()
  • hören()
  • akzeptieren()
  • UNIX-Server
  • Internet-Server
  • Laboratorien

Sockets Input/Output Operationen

  • schreiben(), lesen()
  • send(), recv()
  • sendto(), recvfrom()
  • sendmsg(), recvmsg()
  • sendfile()
  • socketpair()
  • Laboratorien

Socket-Optionen

  • Socket-Optionen erhalten und setzen
  • fcntl()
  • ioctl()
  • getsockopt() und setsockopt()
  • Laboratorien

Netlink-Sockel**

  • Was sind Netlink Sockets?
  • Einen netlink Socket öffnen
  • netlink-Nachrichten
  • Laboratorien

Socket-Multiplexing und konkurrierende Server

  • Multiplexierte und asynchrone Socket-E/A
  • auswählen()
  • poll()
  • pselect() und ppoll()
  • epoll
  • Signalgesteuerte und asynchrone E/A
  • Gleichzeitige Server
  • Laboratorien

Interprozess Communication

  • Methoden der IPC
  • POSIX-IPC
  • System V IPC**
  • Laboratorien

Gemeinsam genutzter Speicher

  • Was ist gemeinsamer Speicher?
  • POSIX Freigegebener Speicher
  • System V Shared Memory**
  • Laboratorien

Semaphoren

  • Was ist eine Semaphore?
  • POSIX-Semaphoren
  • System V-Semaphoren**
  • Laboratorien

Nachrichten-Warteschlangen

  • Was sind Nachrichten-Warteschlangen?
  • POSIX-Nachrichten-Warteschlangen
  • System-V-Nachrichten-Warteschlangen**
  • Laboratorien

Voraussetzungen

Dieser Kurs richtet sich an erfahrene Entwickler. Die Teilnehmer sollten die C-Programmierung beherrschen und mit den grundlegenden Linux Dienstprogrammen und Texteditoren vertraut sein.

Teilnehmerkreis

Dieser Kurs richtet sich an erfahrene Entwickler. Die Teilnehmer sollten die C-Programmierung beherrschen und mit den grundlegenden Linux-Hilfsprogrammen und Texteditoren vertraut sein.

Erfahrungsstufe: Fortgeschrittene

  28 Stunden

Teilnehmerzahl



Preis je Teilnehmer

Kombinierte Kurse

Verwandte Kategorien