Anhang C. Makros und Funktionen des Kernels kurz gefasst

__copy_from_user

#include <asm/uaccess.h>

unsigned long __copy_from_user(void *to, const void *from, unsigned long bytes_to_copy);

Die Funktion kopiert Daten von der im User-Space liegenden Speicherstelle »from« in den Kernel-Space an die Adresse »to«. Insgesamt werden »bytes_to_copy« Bytes kopiert. Die Funktion überprüft nicht die Gültigkeit des Speicherbereiches, auf den der Zeiger »from« zeigt.

Rückgabewert. Die Funktion gibt die Anzahl Zeichen zurück, die nicht kopiert wurden. Im fehlerfreien Fall wird damit »0« zurückgegeben.

__copy_to_user

#include <asm/uaccess.h>
unsigned long __copy_to_user(void *to, const void *from, unsigned long bytes_to_copy);

Ab der Speicherstelle »from«, die im Kernel-Space liegt, werden an die Speicheradresse »to«, die im User-Space liegt, »bytes_to_copy« Bytes kopiert. Diese Funktion überprüft nicht, ob der Speicherbereich, auf den »from« zeigt, gültig ist oder nicht.

Rückgabewert. Die Funktion gibt die Anzahl Zeichen zurück, die nicht kopiert wurden. Im fehlerfreien Fall wird damit »0« zurückgegeben.

__DECLARE_SEMAPHORE_GENERIC

#include <asm/semaphore.h>

DECLARE_SEMAPHORE_GENERIC(name, count);

Dieses Makro definiert eine Variable vom Typ struct semaphore mit dem Namen »name«. Das Semaphor wird mit dem Wert »count« vorbelegt.

__get_user

#include <asm/uaccess.h>

int __get_user(variable, source);

Die Funktion liest von der Adresse »source« einen Wert in die Variable »variable«. Der Wert kannn 1, 2, 4 oder 8 Byte haben, abhängig vom Datentyp des Parameters »source«. Vor dem Datentransfer wird die Gültigkeit des Parameters »source« – anders als bei der Funktion get_user – verifiziert.

Die Funktion kann die zugehörige Treiberinstanz schlafen legen.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen (negativen) Fehlercode (»-EFAULT«) zurück.

__put_user

#include <asm/uaccess.h>

int __put_user(datum, destination);

Dieses Makro kopiert den Wert »datum« (1, 2, 4 oder 8 Byte) in den Speicherbereich einer Applikation an die Adresse »destination«. Es wird nicht überprüft, ob »destination« gültig ist oder nicht.

Die Funktion kann die zugehörige Treiberinstanz schlafen legen.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen (negativen) Fehlercode (»-EFAULT«) zurück.

_IOC

#include <asm/ioctl.h>

_IOC(dir, type, nr, size);

Das Makro bildet aus der Transferrichtung »dir« (_IOC_NONE, _IOC_READ, _IOC_WRITE), dem Typ »type«, der Kommandonummer »nr« und der Anzahl zu transferierender Daten »size« ein IO-Control.

Rückgabewert. Das Makro erzeugt den Code für das IO-Control.

access_ok

#include <asm/uaccess.h>

int access_ok(type, addr, size);

Das Makro überprüft, ob der in »type« spezifizierte Zugriff (VERIFY_READ oder VERIFY_WRITE) auf den Speicherbereich, beginnend bei »addr« und »size« Bytes umfassend, möglich und erlaubt ist oder nicht.

Rückgabewert. Das Makro gibt »0« zurück, falls der Zugriff nicht möglich ist.

add_disk

#include <linux/genhd.h>

void add_disk(struct gendisk *disk);

Über diese Funktion wird das Blockgerät »disk« beim Blockgeräte-Subsystem angemeldet.

add_timer

#include <linux/timer.h>

void add_timer(struct timer_list *timer);

Über diese Inline-Funktion kann eine Funktion (Thread) zu einem anzugebenden Zeitpunkt (in Jiffies) durch das Betriebssystem ausgeführt werden. Die Funktion und eventuelle Parameter zu der Funktion werden in der Struktur »timer« beschrieben. Die Zeit, zu der die Funktion »timer->function« ausgeführt wird, steht im Feld »timer->expires« und wird in Jiffies angegeben. Die wichtigsten Elemente der Struktur struct timer_list sind:

struct timer_list {
    ...
    unsigned long expires;
    unsigned long data;
    void (*function)(unsigned long);
};

add_timer_on

#include <linux/timer.h>

void add_timer_on(struct timer_list *timer, cpu);

Der »timer« wird zur Bearbeitung auf CPU »cpu« aktiviert. Es ist darauf zu achten, dass der Timer »timer« nicht bereits vorher aktiviert wurde. Siehe auch add_timer.

alloc_chrdev_region

#include <linux/fs.h>

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, char *name);

Die Funktion reserviert eine Anzahl von »count«-Gerätenummern. Die erste Gerätenummer wird von der Funktion im Parameter »dev« abgelegt. Die Reservierung selbst wird innerhalb des Kernels unter dem Namen »name« geführt. »baseminor« ist die erste zu verwendende Minor-Nummer.

Rückgabewert. Bei Erfolg gibt die Funktion »0« zurück, ansonsten einen Fehlercode.

alloc_disk

#include <linux/genhd.h>

struct gendisk * alloc_disk(int minors);

Ein Blockgerät ist durch ein Objekt vom Typ struct gendisk repräsentiert. Diese Funktion dient dazu, Speicher für ein solches Objekt zu allozieren und zu initialisieren. Da der notwendige Speicherbereich abhängig von der Anzahl der unterstützten Minor-Nummern ist, muss diese beim Aufruf (»minors«) mit übergeben werden. Der Parameter »minors« legt letztlich die Anzahl der unterstützten Partitionen eines Blockgerätes fest. Wird die Minornumber mit 1 angegeben, so unterstützt das Gerät keine Partitionierung.

Da die Funktion intern kmalloc verwendet, kann die zugehörige Treiberinstanz schlafen gelegt werden.

Rückgabewert. Die Funktion gibt die Adresse des Gendisk-Objektes zurück oder – im Fehlerfall – »NULL«.

alloc_netdev

#include <linux/netdevice.h>

struct net_device *alloc_netdev(int sizeof_priv, const char *name, void (*setup)(struct net_device *));

Mit dieser Funktion wird der Speicher für ein Objekt vom Typ struct net_device angelegt und die Funktion »setup« aufgerufen. Die Funktion »setup« bekommt die Adresse des neuen Objektes übergeben und muss dieses initialisieren. Danach wird noch der Name des neuen Netzgeräte-Objektes auf »name« gesetzt.

Ist »sizeof_priv« ungleich »0«, wird direkt Speicher für private Daten (Daten, die der Netzwerktreiber mit der Struktur verknüpfen kann) angelegt und das Element priv mit der entsprechenden Adresse belegt.

Da die Funktion intern kmalloc aufruft, kann eine zugehörige Treiberinstanz »schlafen« gelegt werden.

Rückgabewert. Die Funktion gibt die Adresse der allozierten struct net_device zurück, oder im Fehlerfall »NULL«.

alloc_skb

#include <linux/skbuff.h>

struct sk_buff *alloc_skb(unsigned int size, int gfp_mask);

Die Funktion alloziert einen neuen »socket buffer« mit einem Datenbuffer der Länge »size« Bytes, wobei der gesamte Buffer für Daten zur Verfügung steht (head==data). Der Usage-Count des Buffers wird auf 1 gesetzt. Innerhalb einer ISR darf die Funktion nur aufgerufen werden, wenn »gfp_mask« mit dem Wert GFP_ATOMIC belegt ist.

Rückgabewert. Im Fehlerfall wird »NULL« zurückgegeben, ansonsten die Adresse des »socket buffers«.

alloc_XXXXdev

#include <linux/XXXXdevice.h>

struct net_device *alloc_XXXXdev(int sizeof_priv);

Die Funktion alloziert und initialisiert ein Objekt vom Typ struct net_device. Die einzelnen Elemente der Datenstruktur werden mit den netzwerkspezifischen Werten ausgefüllt. Nach Aufruf dieser Funktion muss das Gerät prinzipiell nur noch beim Netzwerk-Subsystem durch Aufruf der Funktion register_netdev angemeldet werden.

Als Netzwerke sind beispielsweise vordefiniert: Ethernet, FDDI, HIPPI, Token Ring und Fibre Channel. Die jeweiligen Funktionen heißen damit (Ausprägungen von XXXX):

Komm.-SystemFunktionsname Header-Datei
Ethernetalloc_etherdev <linux/etherdevice.h>
FDDIalloc_fddidev <linux/fddidevice.h>
HIPPIalloc_hippi_dev <linux/hippidevice.h>
Token Ringalloc_trdev <linux/trdevice.h>
Fibre Channelalloc_fc_dev <linux/fcdevice.h>

Zusätzlich zum eigentlichen Objekt wird ein Speicherbereich der Größe »sizeof_priv« Bytes reserviert und die Adresse dieses Speicherbereiches in das Element priv eingetragen.

Rückgabewert. Gibt im Fehlerfall »NULL« zurück, ansonsten die Adresse des Objektes vom Typ struct net_device.

allow_signal

#include <linux/sched.h>

int allow_signal(int signalnummer);

Die Funktion gibt für den gerade aktiven Prozess das Signal »signalnummer« frei.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück. Ist das Signal »signalnummer« nicht bekannt (außerhalb des erlaubten Bereichs), returniert sie »-EINVAL«.

atomic_add

#include <asm/atomic.h>

void atomic_add(int i, atomic_t *v);

Die Funktion addiert zu der Variablen »v« den Wert »i«.

atomic_add_and_test

#include <asm/atomic.h>

int atomic_add_and_test(int i, atomic_t *v);

Die Funktion addiert auf die Variable »v« den Wert »i«.

Rückgabewert. Die Funktion gibt für »v« ungleich »0« den Wert »0« zurück, ansonsten true.

atomic_add_negative

#include <asm/atomic.h>

int atomic_add_negative(int i, atomic_t *v);

Die Funktion addiert atomar den Wert »i« auf die Variable »v«.

Rückgabewert. Die Funktion gibt »0« zurück, falls das Ergebnis der Operation größer oder gleich »0« ist; ansonsten – das Ergebnis ist negativ – wird true zurückgegeben.

atomic_dec

#include <asm/atomic.h>

void atomic_dec(atomic_t *v);

Die Funktion dekrementiert die Variable »v«.

atomic_dec_and_test

#include <asm/atomic.h>

int atomic_dec_and_test(atomic_t *v);

Die Funktion dekrementiert »v«. Die Operation ist atomar.

Rückgabewert. Die Funktion gibt für »v« ungleich »0« den Wert »0« zurück, ansonsten true.

atomic_inc

#include <asm/atomic.h>

void atomic_inc(atomic_t *v);

Die Funktion inkrementiert die Variable »v«.

atomic_inc_and_test

#include <asm/atomic.h>

int atomic_inc_and_test(atomic_t *v);

Die Funktion inkrementiert »v«. Die Operation ist atomar.

Rückgabewert. Die Funktion gibt für »v« ungleich »0« den Wert »0« zurück, ansonsten true.

ATOMIC_INIT

#include <asm/atomic.h>

atomic_t ATOMIC_INIT(i);

Das Makro weist einer Atomic-Variablen den Wert »i« zu.

atomic_read

#include <asm/atomic.h>

int atomic_read(atomic_t *v);

Das Makro liest den Wert von »v«.

Rückgabewert. Das Makro gibt den Wert der Variablen »v« zurück.

atomic_set

#include <asm/atomic.h>

void atomic_set(atomic_t *v, int i);

Das Makro setzt die Variable »v« auf den Wert »i«.

atomic_sub

#include <asm/atomic.h>

void atomic_sub(int i, atomic_t *v);

Die Funktion subtrahiert von der Variablen »v« den Wert »i«.

atomic_sub_and_test

#include <asm/atomic.h>

int atomic_sub_and_test(int i, atomic_t *v);

Die Funktion subtrahiert von der Variablen, auf die »v« zeigt, »i«.

Rückgabewert. Die Funktion gibt für »v« ungleich »0« den Wert »0« zurück, ansonsten true.

barrier

#include <linux/compiler.h>

void barrier(void);

Dieses Makro stellt sicher, dass der Compiler keinen der direkt nachfolgenden Lese- oder Schreibaufträge vor einem bereits erteilten Schreib- oder Leseauftrag ausführt.

Siehe auch: mb, wmb und rmb.

bio_data

#include <linux/bio.h>

char *bio_data(struct bio *bio);

Das Makro gibt die Adresse des durch »bio« definierten Segmentes zurück.

Rückgabewert. Die Adresse des Segmentes.

bio_data_dir

#include <linux/fs.h>

void bio_data_dir(struct bio *bio);

Das Makro gibt die Transferrichtung des Bio-Blocks »bio« zurück.

Rückgabewert. Das Makro gibt READ oder WRITE zurück. Beide Konstanten sind in <linux/fs.h> deklariert.

blk_alloc_queue

#include <linux/blkdev.h>

request_queue_t blk_alloc_queue(int gfpmask);

Die Funktion reserviert und initialisiert Speicher für die Request-Queue eines Blockgerätes. Die Funktion ruft dazu kmalloc auf. Der Parameter »gfpmask« bestimmt hierbei, auf welche Art der Speicher alloziert wird (siehe kmalloc).

Rückgabewert. Die Funktion gibt die Adresse der Request-Queue zurück oder im Fehlerfall »NULL«.

blk_cleanup_queue

#include <linux/blkdev.h>

void blk_cleanup_queue(request_queue_t *q);

Die Funktion gibt die Request-Queue »q« frei. Die Funktion wird typischerweise aufgerufen, wenn sich ein Blockgeräte-Treiber deinitialisiert. Die Funktion gibt alle Request-Strukturen der Request-Queue frei und schließlich die Request-Queue selbst auch. Die Funktion bildet das Gegenstück zu blk_init_queue oder blk_queue_make_request.

blk_fs_request

#include <linux/blkdev.h>

int blk_fs_request(struct request *q);

Das Makro dient dazu festzustellen, ob es sich bei dem durch »q« gegebenen Auftrag um einen normalen Schreib-/Leseauftrag handelt oder nicht. Die unterschiedlichen Auftragstypen sind in der Header-Datei <linux/blkdev.h> beschrieben.

Rückgabewert. Das Makro gibt einen Wert ungleich Null (True) zurück, falls es sich um einen normalen Schreib- oder Leseauftrag handelt, ansonsten »0« (False).

blk_init_queue

#include <linux/blkdev.h>

request_queue_t *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock);

Die Funktion erzeugt eine Request-Queue zur Verwendung mit einem Blockgerät. Die übergebene Funktion »rfn« wird aufgerufen, sobald zu bearbeitende Aufträge vorliegen. Dabei sammelt und sortiert das Blockgeräte-Subsystem Aufträge.

Es ist nicht notwendig, dass die Funktion »rfn« sämtliche Requests innerhalb der Request-Queue bearbeitet. Allerdings muss die Funktion dafür sorgen, dass die nicht bearbeiteten Requests zu einem späteren Zeitpunkt abgearbeitet werden.

Der Prototyp der Funktion »rfn« sieht folgendermaßen aus:

    void rfn( request_queue_t *q );

Sobald auf die Request-Queue zugegriffen wird, muss das Spinlock »lock« gehalten werden.

Rückgabewert. Die Funktion gibt die Adresse der initialisierten Request-Queue zurück oder – im Fehlerfall – »NULL«.

blk_queue_bounce

#include <linux/blkdev.h>

void blk_queue_bounce(request_queue_t *q, struct bio **bio_orig);

Die Funktion dient dazu, eine durch »*bio_orig« gegebene Speicherseite in einen Speicherbereich zu mappen, in den normal (ohne DMA) zugegriffen werden kann. Die Adresse des neuen Bio-Blocks wird in »bio_orig« abgelegt. »q« kennzeichnet die zugehörige Request-Queue.

blk_queue_make_request

#include <linux/blkdev.h>

void blk_queue_make_request(request_queue_t *q, make_request_fn *mfn);

Mit Hilfe dieser Funktion kann ein Blockgeräte-Treiber die vom System zur Verfügung gestellte »Make-Request-Funktion« gegen die Funktion »mfn« austauschen. Die Make-Request-Funktion hat die Aufgabe, Aufträge einer Applikation zu sammeln und die Reihenfolge zu optimieren. Falls ein Treiber respektive Geräte (das gilt insbesondere für virtuelle Geräte) von dieser Optimierung nicht profitiert, können mit Hilfe einer eigenen Make-Request-Funktion die Aufträge (Bio-Blöcke) direkt entgegengenommen und bearbeitet werden. Der Parameter »q« spezifiziert die Request-Queue, für deren Aufträge die Funktion »mfn« aufgerufen wird.

Der Prototyp der Funktion »mfn« sieht folgendermaßen aus:

int mfn( request_queue_t *q, struct bio *bio );

BUG_ON

#include <asm/bug.h>

void BUG_ON(condition);

Falls die Bedingung »condition« erfüllt ist, wird die Bearbeitung des Codestückes abgebrochen. Der Kernel erzeugt eine Fehlerausgabe, in der unter anderem der Dateiname und die Zeilennummer angegeben werden, in der der Fehler aufgetreten ist. Die Fehlerausgabe wird typischerweise in den Syslogs abgelegt. Die Bedingung wird als normaler Ausdruck der Programmiersprache C definiert.

Siehe auch: WARN_ON.

bus_register

#include <linux/device.h>

int bus_register(struct bus_type *bus);

Mit Hilfe der Funktion wird der im Objekt »bus« spezifizierte Bus beim Gerätemodell angemeldet. Das Gerätemodell legt daraufhin im Sys-Filesystem ein entsprechendes Verzeichnis an.

Rückgabewert. Die Funktion gibt immer »0« zurück.

bus_unregister

#include <linux/device.h>

void bus_unregister(struct bus_type *bus);

Die Funktion meldet den Bus »bus« beim Gerätemodell wieder ab. Der Eintrag im Sys-Filesystem wird gelöscht, sobald keiner mehr auf das Verzeichnis zugreift.

call_usermodehelper

#include <linux/kmod.h>

int call_usermodehelper(char *path, char **argv, char **envp, int wait);

Die Funktion startet die durch »path« gegebene Applikation (im User-Space). Die Applikation bekommt die durch jeweils ein Null-Element abgeschlossenen Parameter »argv« und »envp« als Argumentenliste respektive Environment-Liste übergeben. Ist der Parameter »wait« »1«, blockiert die Funktion so lange, bis sich das aufgerufene Programm beendet hat.

Die Funktion darf nur im Prozess-Kontext aufgerufen werden. Die gestartete Applikation wird als Kind des »keventd« gestartet und läuft somit mit Superuser-Rechten.

Rückgabewert. Falls das Programm »path« nicht gestartet werden konnte, gibt die Funktion den Fehlercode der Funktion execve zurück. Ansonsten, falls »wait« gleich »1« ist, wird der Exitcode des Programms »path« zurückgegeben, ansonsten »0«.

cdev_add

#include <linux/cdev.h>

int cdev_add(struct cdev *driver_object, dev_t device_number, unsigned count);

Die Funktion registriert den durch »driver_object« repräsentierten Treiber beim Kernel. »device_number« gibt die erste , »count« die Anzahl Gerätenummern an, für die der Treiber zuständig ist.

Rückgabewert. Bei Erfolg gibt die Funktion »0« zurück, ansonsten einen Fehlercode.

cdev_alloc

#include <linux/cdev.h>

struct cdev *cdev_alloc(void);

Ein zeichenorientierter Gerätetreiber wird innerhalb des Kernels durch ein Objekt vom Typ struct cdev * repräsentiert. Diese Funktion instantiert ein solches Objekt.

Rückgabewert. Die Funktion gibt die Adresse des instantierten Objektes zurück oder im Fehlerfall »NULL«

cdev_del

#include <linux/cdev.h>

void cdev_del(struct cdev *driver_object);

Die Funktion meldet den durch »driver_object« repräsentierten zeichenorientierten Treiber wieder beim Kernel ab.

cdev_init

#include <linux/cdev.h>

void cdev_init(struct cdev *cdev, struct file_operations *fops);

Die Funktion führt die Basisinitialisierung des übergebenen Elementes »cdev« durch. Insbesondere wird das Element mit der Funktionstabelle »fops« verknüpft.

cdev_unmap

void cdev_unmap(struct cdev *driver_object);

Bis einschließlich Kernel 2.6.2 musste der Treiber selbst dafür sorgen, dass durch Aufruf dieser Funktion der durch »driver_object« repräsentierte Treiber aus internen Listen ausgetragen wird. Die Funktion muss vor Aufruf von cdev_del aufgerufen werden. Ab Kernel 2.6.3 erfolgt der Aufruf implizit (im Kernel) und kann für den Treiber entfallen.

change_bit

#include <asm/bitops.h>

void change_bit(int nr, volatile unsigned long *addr);

Die Funktion toggelt das Bit Nummer »nr« an der Speicheradresse »addr«. Hatte das Bit vor der Operation den Wert »0«, ist das Bit hinterher »1«; war es vorher »1«, ist es hinterher »0«. Der Zugriff auf das Bit über diese Funktion ist unteilbar. Solange die Funktion aktiv ist, kann keine andere Funktion auf die Speicherzelle »addr« zugreifen. Das niederwertigste Bit hat die Nummer »0«.

Siehe auch: test_bit, test_and_change_bit, test_and_clear_bit, test_and_set_bit, clear_bit und set_bit.

CLASS_ATTR

#include <linux/device.h>

CLASS_ATTR(name, mode_t mode, ssize_t (*_show)(struct device *dev, char *buf), ssize_t (*_store)(struct device *dev, const char *buf, size_t count));

Das Makro definiert eine Variable vom Typ struct class_attribute. Die Variable hat einen Namen, der sich zusammensetzt aus »class_attr_« und »name«. Die Variable repräsentiert die Attributdatei einer Klasse im Sys-Filesystem. Die Lesefunktion der Attributdatei wird über »show« angegeben, die Schreibfunktion über »store«. Der Zugriffsmodus auf die Datei wird im Parameter »mode« spezifiziert.

class_create_file

#include <linux/device.h>

int class_create_file(struct class *cls, const struct class_attribute *attr);

Diese Funktion legt im Sys-Filesystem die Attributdatei an, die durch »attr« definiert ist. Die Datei wird in das zur Klasse »cls« gehörige Verzeichnis abgelegt.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten einen negativen Fehlercode (»-EINVAL«) zurück.

class_device_register

#include <linux/device.h>

int class_device_register(struct class_device *class_dev);

Mit Hilfe dieser Funktion wird ein in »class_dev« spezifiziertes Gerät der in »class_dev->class« spezifizierten Geräteklasse übergeben. Diese Funktion ist nur dann aufzurufen, wenn eine Geräteklasse nicht von sich aus die Einträge im Sys-Filesystem des Gerätemodells vornimmt. Das ist gegenwärtig bei den Geräteklassen input und pcmcia-socket der Fall.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück, ansonsten einen Fehlercode (z.B. »-EINVAL«).

class_device_unregister

#include <linux/device.h>

void class_device_unregister(struct class_device *class_dev);

Die Funktion entfernt das durch »class_dev« repräsentierte Gerät aus der zugehörigen Klasse.

class_register

#include <linux/device.h>

int class_register(struct class *cls);

Die Funktion meldet die Klasse »cls« beim Gerätemodell an. Das Sys-Filesystem legt daraufhin im Verzeichnis /sys/class/ ein Unterverzeichnis mit dem Namen »cls->name« an.

Rückgabewert. Die Funktion gibt »0« zurück.

class_remove_file

#include <linux/device.h>

void class_remove_file(struct class *cls, const struct class_attribute *attr);

Diese Funktion löscht die durch »attr« spezifizierte Attributdatei aus dem zur Klasse »cls« gehörigen Verzeichnis im Sys-Filesystem.

class_simple_create

#include <linux/device.h>

struct class_simple *class_simple_create(struct module *owner, char *name);

Die Funktion erzeugt im Gerätemodell die Klasse »name«.

Rückgabewert. Die Funktion gibt im Fehlerfall einen negativen Fehlercode (z.B. »-ENOMEM«), ansonsten das erzeugte Klassen-Objekt zurück.

class_simple_destroy

#include <linux/device.h>

void class_simple_destroy(struct class_simple *cs);

Die Funktion entfernt die Klasse »cs« aus dem Gerätemodell.

class_simple_device_add

#include <linux/device.h>

struct class_device *class_simple_device_add(struct class_simple *cs, dev_t dev, struct device *device, const char *fmt, ...);

Die Funktion hängt das Gerät »device« mit der Gerätenummer »dev« unterhalb des durch »fmt« und den weiteren Argumenten (»...«) gegebenen Namens an die Klasse »cs« an.

Rückgabewert. Die Funktion gibt einen Zeiger auf ein Objekt vom Typ struct class_device zurück, der im folgenden dazu verwendet werden kann, um damit weitere, zugehörige Dateien im Sys-Filesystem zu erzeugen.

class_simple_device_remove

#include <linux/device.h>

void class_simple_device_remove(dev_t dev);

Die Funktion entfernt das durch die Gerätenummer »dev« gegebene Gerät aus der zugehörigen Klasse.

class_unregister

#include <linux/device.h>

void class_unregister(struct class *cls);

Die Funktion meldet die Klasse »cls« beim Gerätemodell ab.

clear_bit

#include <asm/bitops.h>

void clear_bit(int nr, volatile unsigned long *addr);

Die Funktion löscht das Bit Nummer »nr« an der Speicheradresse »addr«. Der Zugriff auf das Bit über diese Funktion ist unteilbar. Solange die Funktion aktiv ist, kann keine andere Funktion auf die Speicherzelle »addr« zugreifen. Das niederwertigste Bit hat die Nummer »0«.

Siehe auch: test_bit, test_and_change_bit, test_and_clear_bit, test_and_set_bit, change_bit und set_bit.

complete

#include <linux/completion.h>

void complete(struct completion *x);

Die Funktion erhöht den Zählerwert des Completion-Objekts »x« und weckt die auf das Completion-Objekt wartenden Prozesse auf.

Siehe auch: DECLARE_COMPLETION, init_completion, complete_all, complete_and_exit und wait_for_completion.

complete_all

#include <linux/completion.h>

void complete_all(struct completion *x);

Die Funktion setzt den Zählerwert des Completion-Objekts »x« auf den höchstmöglichen Wert und weckt die auf das Completion-Objekt wartenden Prozesse auf. Dies ist gleichbedeutend mit einem Mehrfach-Aufruf der Funktion complete. Aufgrund des hohen Zählwertes legt sich ein auf das Completion-Objekt wartender Rechenprozess nicht wieder schlafen.

Siehe auch: DECLARE_COMPLETION, init_completion, complete, complete_and_exit und wait_for_completion.

complete_and_exit

#include <linux/kernel.h>

void complete_and_exit(struct completion *x);

Die Funktion ruft die Funktion complete mit »x« als Parameter auf und beendet sich danach selbst. Die Funktion wird von Kernel-Threads benutzt, um anderen Instanzen das Ende des Kernel-Threads mitzuteilen.

Siehe auch: DECLARE_COMPLETION, init_completion, complete, complete_all und wait_for_completion.

copy_from_user

#include <asm/uaccess.h>

unsigned long copy_from_user(void *to, const void *from, unsigned long bytes_to_copy);

Die Funktion kopiert Daten von der im User-Space liegenden Speicherstelle »from« in den Kernel-Space an die Adresse »to«. Insgesamt werden »bytes_to_copy« Bytes kopiert. Bevor die Daten kopiert werden, wird überprüft, ob der Speicherbereich, auf den »from« zeigt, gültig ist oder nicht.

Rückgabewert. Die Funktion gibt die Anzahl Zeichen zurück, die nicht kopiert wurden. Im fehlerfreien Fall wird damit »0« zurückgegeben.

copy_to_user

#include <asm/uaccess.h>

unsigned long copy_to_user(void *to, const void *from, unsigned long bytes_to_copy);

Ab der Speicherstelle »from«, die im Kernel-Space liegt, werden an die Speicheradresse »to«, die im User-Space liegt, »bytes_to_copy« Bytes kopiert. Vor der Kopieraktion überprüft die Funktion, ob der Speicherbereich, auf den »from« zeigt, gültig ist oder nicht.

Rückgabewert. Die Funktion gibt die Anzahl Zeichen zurück, die nicht kopiert wurden. Im fehlerfreien Fall wird damit »0« zurückgegeben.

cpu_has_tsc

#include <asm/cpufeature.h>

int cpu_has_tsc();

Das Makro gibt an, ob die CPU ein Taktzyklenregister besitzt oder nicht. Derartige Makros gibt es auch für andere Features der CPU.

Rückgabewert. Das Makro gibt einen Wert ungleich »0« zurück, falls ein Taktzyklenregister existiert.

create_proc_entry

#include <linux/proc_fs.h>

struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode, struct proc_dir_entry *parent);

Über diese Funktion wird ein Eintrag im Proc-Filesystem erstellt. Dazu spezifiziert der Treiber den Namen (»name«) des neuen Eintrags, den Modus (z.B. S_ISDIR) und schließlich die Stelle (»parent«), an der der Eintrag vorgenommen werden soll.

Rückgabewert. Im Fehlerfall (kein Speicher zum Allozieren der Datenstruktur) gibt die Funktion »NULL« zurück, ansonsten die Adresse der Struktur, die den neuen Eintrag repräsentiert.

create_proc_read_entry

#include <linux/proc_fs.h>

struct proc_dir_entry * create_proc_read_entry(const char *name, mode_t mode, struct proc_dir_entry *base, read_proc_t *read_proc, void *data);

Die Inline-Funktion erzeugt einen Procdir-Eintrag mit Namen »name« im Verzeichnis, welches durch »base« repräsentiert ist. Typ und Zugriffsrechte des erzeugten Eintrags werden über »mode« festgelegt. Außerdem wird in der den Eintrag spezifizierenden Struktur vom Typ »struct proc_dir_entry« (Rückgabewert der Funktion) die Lesefunktion »read_proc« eingehängt.

Rückgabewert. Im Fehlerfall (kein Speicher zum Allozieren der Datenstruktur) gibt die Funktion »NULL« zurück, ansonsten die Adresse der Struktur, welche den neuen Eintrag repräsentiert.

create_workqueue

#include <linux/workqueue.h>

struct workqueue_struct *create_workqueue(const char *name);

Die Funktion erzeugt eine Workqueue. Der Kernel-Thread, der die Workqueue implementiert, wird unter dem Namen »name« geführt. Da der Speicher für das Objekt dynamisch alloziert wird, darf die Funktion nicht im Interrupt-Kontext abgearbeitet werden.

Siehe auch: flush_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_work, queue_delayed_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

Rückgabewert. Die Funktion gibt die Adresse des Workqueue-Objektes zurück.

current_kernel_time

#include <linux/time.h>

struct timespec current_kernel_time (void);

Die globale Variable xtime zählt die Sekunden und Nanosekunden, die seit dem 1.1.1970 vergangen sind. Der Zugriff auf diese Variable ist über ein Sequence-Lock gesichert. Über diese Funktion kann eine Kopie des Inhalts von xtime erhalten werden.

Rückgabewert. Die Funktion gibt die Zeit in Sekunden und Nanosekunden seit dem 1.1.1970 zurück.

daemonize

#include <linux/sched.h>

void daemonize(const char *formatstring, ...);

Diese Systemfunktion befreit die mit einem Kernel-Thread assoziierten etwaigen Ressourcen im User-Space. Außerdem gibt sie dem Kernel-Thread den durch den Formatstring »formatstring« und den zusätzlichen Parametern »...« spezifizierten Namen.

DECLARE_COMPLETION

#include <linux/completion.h>

DECLARE_COMPLETION(struct completion *name);

Das Makro ist für die statische Definition des Completion-Objekts »name« zuständig. Das Objekt wird mit dem Namen »name« erzeugt und gleich initialisiert. Alternativ kann das Objekt auch dynamisch (während der Laufzeit) über init_completion initialisiert werden.

Siehe auch: init_completion, complete, complete_all, complete_and_exit und wait_for_completion.

DECLARE_MUTEX

#include <asm/semaphore.h>

void DECLARE_MUTEX(name);

Dieses Makro definiert eine Variable vom Typ struct semaphore mit dem Namen »name« als Mutex. Das Mutex ist nach Aufruf der Funktion unbelegt (frei). Ein Mutex ist ein Semaphor mit dem Initialwert »1«. Es schützt also einen kritischen Abschnitt, der genau von einem Prozess betreten werden darf. Mutexe und Semaphore stehen nur im Prozess- oder User-Kontext zur Verfügung.

DECLARE_MUTEX_LOCKED

#include <asm/semaphore.h>

void DECLARE_MUTEX_LOCKED(name);

Dieses Makro definiert eine Variable vom Typ struct semaphore mit dem Namen »name« als Mutex. Das Mutex ist nach Aufruf der Funktion belegt, der mit dem Mutex geschützte kritische Abschnitt gilt als betreten. Ein Mutex ist ein Semaphor mit dem Initialwert »1«. Es schützt also einen kritischen Abschnitt, der genau von einem Prozess betreten werden darf. Mutexe und Semaphore stehen nur im Prozess- oder User-Kontext zur Verfügung.

DECLARE_TASKLET

#include <linux/interrupt.h>

DECLARE_TASKLET(struct tasklet_struct name, void (*func)(unsigned long), unsigned long data);

Dieses Makro definiert ein Tasklet mit dem Namen »name« und weist diesem die Funktion »func« und den zu übergebenden Parameter »data« zu.

Siehe auch: DECLARE_TASKLET_DISABLED, tasklet_init, tasklet_kill, tasklet_schedule, tasklet_hi_schedule, tasklet_disable und tasklet_enable.

DECLARE_TASKLET_DISABLED

#include <linux/interrupt.h>

DECLARE_TASKLET_DISABLED(struct tasklet_struct name, void (*func)(unsigned long), unsigned long data);

Dieses Makro definiert ein Tasklet mit dem Namen »name« und weist diesem die Funktion »func« und den zu übergebenen Parameter »data« zu. Das Tasklet wird disabled, so dass es auch dann nicht aufgerufen wird, falls es gescheduled wird. Mit Hilfe der Funktion tasklet_enable kann die Abarbeitung dann angestoßen werden.

Siehe auch: DECLARE_TASKLET, tasklet_init, tasklet_kill, tasklet_schedule, tasklet_hi_schedule, tasklet_disable und tasklet_enable.

DECLARE_WORK

#include <linux/workqueue.h>

DECLARE_WORK(struct work_struct name, void (*func)(void *), void *data);

Dieses Makro legt ein Work-Objekt mit dem Namen »name« an. Sobald das Objekt einer Workqueue übergeben wird, wird die Funktion »func« abgearbeitet. Der Funktion wird beim Aufruf »data« übergeben.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, INIT_WORK, queue_work, queue_delayed_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

del_gendisk

#include <linux/genhd.h>

void del_gendisk(struct gendisk *disk);

Die Funktion gibt das Blockgeräte-Objekt »disk« frei. Sie wird typischerweise bei der Deinitialisierung des Blockgeräte-Treibers aufgerufen.

del_timer

#include <linux/timer.h>

int del_timer(struct timer_list *timer);

Diese Funktion dient zum Deaktivieren des Timers »timer«. Sie kann sowohl mit aktiven als auch mit inaktiven Timern verwendet werden. Im Normalfall sollte die Funktion del_timer_sync gewählt werden, die sowohl für Ein- als insbesondere auch für Mehrprozessorsysteme (SMP) geeignet ist.

Rückgabewert. Die Funktion gibt »0«, falls der Timer »timer« inaktiv war, ansonsten »1« zurück.

del_timer_sync

#include <linux/timer.h>

int del_timer_sync(struct timer_list *timer);

Diese Funktion dient zum Deaktivieren des Timers »timer«. Wird auf einem Mehrprozessorsystem der zu löschende Timer zum gleichen Zeitpunkt auf einem anderen Prozessor bearbeitet, wartet die Funktion das Ende der Bearbeitung ab, bevor sie zurückkehrt. Die Funktion darf nicht im Interrupt-Kontext aufgerufen werden!

Rückgabewert. Die Funktion gibt »0« zurück, falls der Timer »timer« inaktiv war, ansonsten returniert sie »1«.

destroy_workqueue

#include <linux/workqueue.h>

void destroy_workqueue(struct workqueue_struct *wq);

Die Funktion ruft zunächst flush_workqueue auf, beendet den zugehörigen Kernel-Thread und gibt den mit der Workqueue verknüpften Speicher frei.

Siehe auch: create_workqueue, flush_workqueue, INIT_WORK, DECLARE_WORK, queue_work, queue_delayed_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

dev_alloc_skb

#include <linux/netdevice.h>

struct sk_buff *dev_alloc_skb(unsigned int length);

Die Inline-Funktion reserviert einen Socket-Buffer der Länge »length« (siehe alloc_skb). Auch wenn der Speicher dynamisch alloziert wird, darf die Funktion im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Die Funktion gibt die Adresse des neuen Socket-Buffers zurück, beziehungsweise im Fehlerfall »NULL«.

dev_kfree_skb

#include <linux/skbuff.h>

void dev_kfree_skb(struct sk_buff *skb);

Die Funktion dekrementiert den Referenz-Zähler des Buffers »skb«. Wenn der Socket Buffer von keiner Instanz mehr verwendet wird, wird der Buffer freigegeben.

devfs_mk_bdev

#include <linux/devfs_fs_kernel.h>

int devfs_mk_bdev(dev_t dev, umode_t mode, const char *fmt, ...);

Mit dieser Funktion meldet sich der Treiber, der sich zuvor mit der Gerätenummer »dev« als blockorientierter Treiber beim Kernel angemeldet hat, beim Device-Filesystem an. Das Device-Filesystem legt daraufhin einen Eintrag mit dem über den Formatstring »fmt« und den Parametern »...« gebildeten Namen im Device-Verzeichnis an. Der dort angelegte Eintrag erhält die in »mode« spezifizierten Zugriffsrechte.

Die Flags für die Zugriffsrechte sind in der Header-Datei <linux/stat.h> deklariert. S_IFBLK muss bei einem zeichenorientierten Gerät immer gesetzt sein.

Das Device-Filesystem wird in kommenden Linux-Versionen nicht mehr unterstützt werden.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück, ansonsten einen negativen Fehlercode. »-EINVAL« wird zurückgegeben, falls »mode« falsch parametriert oder der Formatstring ungültig ist, »-ENOMEM«, falls kein Speicher zur Verfügung steht..

devfs_mk_cdev

#include <linux/devfs_fs_kernel.h>

int devfs_mk_cdev(dev_t dev, umode_t mode, const char *fmt, ...);

Mit dieser Funktion meldet sich der Treiber, der sich zuvor mit der Gerätenummer »dev« als zeichenorientierter Treiber beim Kernel angemeldet hat, beim Device-Filesystem an. Das Device-Filesystem legt daraufhin einen Eintrag mit dem über den Formatstring »fmt« und den Parametern »...« gebildeten Pfad und Namen im Device-Verzeichnis an. Der dort angelegte Eintrag erhält die in »mode« spezifizierten Zugriffsrechte.

Die Flags für die Zugriffsrechte sind in der Header-Datei <linux/stat.h> deklariert. S_IFCHR muss bei einem zeichenorientierten Gerät immer gesetzt sein.

Das Device-Filesystem wird in kommenden Linux-Versionen nicht mehr unterstützt werden.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück, ansonsten einen negativen Fehlercode. »-EINVAL« wird zurückgegeben, falls »mode« falsch parametriert oder der Formatstring ungültig ist, »-ENOMEM« falls kein Speicher zur Verfügung steht..

devfs_mk_dir

#include <linux/devfs_fs_kernel.h>

int devfs_mk_dir(const char *fmt, ...);

Mit dieser Funktion wird im Device-Verzeichnis ein Unterverzeichnis erzeugt, welches über »fmt« und den Parametern »...« gebildet wird. Die Verwendung dieser Funktion ist optional, da Unterverzeichnisse automatisch beim Anlegen der Device-Einträge erzeugt werden.

Das Device-Filesystem wird in kommenden Linux-Versionen nicht mehr unterstützt werden.

Rückgabewert. Im Fall eines Fehlers gibt die Funktion »NULL« zurück.

devfs_mk_symlink

#include <linux/devfs_fs_kernel.h>

int devfs_mk_symlink(const char *from, const char *to);

Die Funktion erzeugt einen symbolischen Link im Namensraum des Device-Filesystems vom Eintrag »from« mit dem Namen »to«.

Rückgabewert. Bei Erfolg gibt die Funktion »0«, sonst einen negativen Fehlercode zurück.

devfs_remove

#include <linux/devfs_fs_kernel.h>

void devfs_remove(const char *fmt, ...);

Die Funktion entfernt den durch »fmt« und den Parametern »...« dynamisch erzeugten Gerätedateieintrag wieder.

Das Device-Filesystem wird in zukünftigen Linux-Versionen nicht mehr unterstützt werden.

DEVICE_ATTR

#include <linux/device.h>

DEVICE_ATTR(name, mode_t mode, ssize_t (*_show)(struct device *dev, char *buf), ssize_t (*_store)(struct device *dev, const char *buf, size_t count));

Das Makro definiert eine Variable vom Typ struct device_attribute. Die Variable hat einen Namen, der sich zusammensetzt aus »dev_attr_« und »name«. Die Variable repräsentiert eine Attributdatei im Sys-Filesystem. Die Lesefunktion der Attributdatei wird über »show« angegeben, die Schreibfunktion über »store«. Der Zugriffsmodus auf die Datei wird im Parameter »mode« spezifiziert.

device_bind_driver

#include <linux/device.h>

void device_bind_driver(struct device *dev);

Die Funktion dient dazu, das Gerät »dev« mit dem Treiber »dev->driver« im Sys-Filesystem zu verknüpfen.

device_create_file

#include <linux/device.h>

int device_create_file(struct device *dev, struct device_attribute *attr);

Diese Funktion legt im Sys-Filesystem die Attributdatei an, die durch »attr« definiert ist. Die Datei wird in das zum Gerät »dev« gehörige Verzeichnis abgelegt.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten einen negativen Fehlercode (»-EINVAL«) zurück.

device_remove_file

#include <linux/device.h>

void device_remove_file(struct device *dev, struct device_attribute *attr);

Diese Funktion löscht die durch »attr« spezifizierte Attributdatei aus dem zum Gerät »dev« gehörigen Verzeichnis im Sys-Filesystem.

do_gettimeofday

#include <linux/time.h>

void do_gettimeofday(struct timeval *tv);

Ähnlich der Funktion gettimeofday auf Applikationsebene erfragt im Kernel die Funktion do_gettimeofday die Zeit. Nach Aufruf der Funktion befinden sich Sekunden und μ-Sekunden in den entsprechenden Feldern von »tv«. Da die Funktion – soweit möglich – das Taktzyklenregister des Prozessors nutzt, um die Zeit zu erhalten, ist die Genauigkeit der Funktion höher als Mikrosekunden.

Die struct timeval ist in der Header-Datei <linux/time.h> deklariert:

struct timeval {
    time_t      tv_sec;  /* seconds */
    suseconds_t tv_usec; /* microseconds */
};

down

#include <asm/semaphore.h>

void down(struct semaphore *sem);

Diese Inline-Funktion wird beim Eintritt in den kritischen Abschnitt aufgerufen (P-Operation). Der Zählwert des Semaphor »sem« wird um eins erniedrigt. Ist der Zähler kleiner »0«, wird der zugehörige Prozess (Treiberinstanz, Kernel-Thread) schlafen gelegt. Der Prozess wird erst wieder aufgeweckt, wenn der kritische Abschnitt frei ist. Die Funktion darf nicht im Interrupt-Kontext verwendet werden.

Siehe auch: sema_init, up, down_interruptible und down_trylock.

down_interruptible

#include <asm/semaphore.h>

int down_interruptible(struct semaphore *sem);

Diese Inline-Funktion wird beim Eintritt in den kritischen Abschnitt aufgerufen (P-Operation). Der Zählwert des Semaphor »sem« wird um eins erniedrigt. Ist der Zähler kleiner »0«, wird der zugehörige Prozess (Treiberinstanz, Kernel-Thread) schlafen gelegt. Der Prozess wird aufgeweckt, wenn entweder der kritische Abschnitt frei ist oder dem wartenden Prozess ein Signal geschickt wurde. Die Funktion darf nicht im Interrupt-Kontext verwendet werden.

Siehe auch: sema_init, up, down und down_trylock.

Rückgabewert. Die Funktion gibt »0« zurück, wenn der kritische Abschnitt betreten werden kann. Falls die Funktion unterbrochen wurde, returniert sie »-EINTR«.

down_read

#include <linux/rwsem.h>

void down_read(struct rw_semaphore *rwsema);

Diese Inline-Funktion wird aufgerufen, wenn der durch »rwsema« geschützte kritische Abschnitt betreten werden soll, ohne dass darin Modifikationen durchgeführt werden (rein lesender Zugriff). Der Prozess muss warten, falls das Lese-/Schreib-Semaphor nicht frei ist. Die Funktion darf daher nicht im Interrupt-Kontext aufgerufen werden.

Siehe auch: init_rwsem, down_write, down_read_trylock, down_write_trylock, downgrade_write, up_read und up_write.

down_read_trylock

#include <linux/rwsem.h>

int down_read_trylock(struct rw_semaphore *rw_sema);

Die Funktion versucht das Lese-/Schreib-Semaphor »rw_sema« für den lesenden Zugriff zu reservieren. Anhand des Rückgabewertes ist ersichtlich, ob dies erfolgreich war oder nicht.

Siehe auch: init_rwsem, down_read, down_write, up_read und up_write.

Rückgabewert. Ein Rückgabewert von »1« bedeutet Erfolg, bei einem Rückgabewert von »0« ist das Semaphor bereits durch eine andere Instanz (zum Schreiben) belegt.

down_trylock

#include <asm/semaphore.h>

int down_trylock(struct semaphore *sem);

Die Inline-Funktion versucht das Semaphor »sem« zu reservieren.

Siehe auch: sema_init, up, down und down_interruptible.

Rückgabewert. Die Funktion gibt im Erfolgsfall (Semaphor ist reserviert) »0« zurück. Ist das Semaphor belegt, returniert sie einen Wert ungleich »0«.

down_write

#include <linux/rwsem.h>

void down_write(struct rw_semaphore *sema);

Diese Inline-Funktion wird aufgerufen, wenn der durch »sema« geschützte kritische Abschnitt zum Schreiben betreten werden soll. Ist das Lese-/Schreib-Semaphor belegt, wird der aufrufende Prozess (Treiberinstanz) so lange schlafen gelegt, bis das Lese-/Schreib-Semaphor wieder frei geworden ist. Die Funktion darf nicht im Interrupt-Kontext verwendet werden.

Siehe auch: init_rwsem, down_read, down_read_trylock, down_write_trylock, downgrade_write, up_read und up_write.

down_write_trylock

#include <linux/rwsem.h>

int down_write_trylock(struct rw_semaphore *sem);

Diese Inline-Funktion wird aufgerufen, wenn der durch »sema« geschützte kritische Abschnitt zum Schreiben betreten werden soll. Ist das Lese-/Schreib-Semaphor belegt, wird der aufrufende Prozess (Treiberinstanz, Kernel-Thread) nicht in den Wartezustand versetzt, sondern »0« zurückgegeben. Der kritische Abschnitt darf dann nicht betreten werden.

Siehe auch: init_rwsem, down_read, down_write, down_read_trylock, downgrade_write, up_read und up_write.

Rückgabewert. Die Funktion gibt »1« zurück, falls der kritische Abschnitt zum Schreiben betreten werden darf und »0«, wenn das Semaphor von einem anderen Prozess gehalten wird.

downgrade_write

#include <linux/wait.h>

void downgrade_write(struct rw_semaphore *rw_sema);

Das für einen Schreibzugriff reservierte Lese-/Schreib-Semaphor »rw_sema« wird zu einem Lesezugriff herabgestuft. Die Funktion darf nicht im Interrupt-Kontext verwendet werden.

Siehe auch: init_rwsem, down_read, down_write, down_read_trylock, down_write_trylock, downgrade_write, up_read und up_write.

DRIVER_ATTR

#include <linux/device.h>

DRIVER_ATTR(name, mode_t mode, ssize_t (*_show)(struct device *dev, char *buf), ssize_t (*_store)(struct device *dev, const char *buf, size_t count));

Das Makro definiert eine Variable vom Typ struct driver_attribute. Die Variable hat einen Namen, der sich zusammensetzt aus »dev_attr_« und »name«. Die Variable repräsentiert eine Attributdatei für einen Treiber im Sys-Filesystem. Die Lesefunktion der Attributdatei wird über »show« angegeben, die Schreibfunktion über »store«. Der Zugriffsmodus auf die Datei wird im Parameter »mode« spezifiziert.

driver_create_file

#include <linux/device.h>

int driver_create_file(struct device_driver *drv, struct driver_attribute *attr);

Diese Funktion legt im Sys-Filesystem die Attributdatei an, die durch »attr« definiert ist. Die Datei wird in dem zum Treiber »drv« gehörigen Verzeichnis abgelegt.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten einen negativen Fehlercode (»-EINVAL«) zurück.

driver_register

#include <linux/device.h>

int driver_register(struct device_driver *drv);

Der Treiber »drv« meldet sich mit Hilfe dieser Funktion bei dem Bus »drv->bus« beim Gerätemodell an.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen Fehlercode zurück.

driver_remove_file

#include <linux/device.h>

void driver_remove_file(struct device_driver *drv, struct driver_attribute *attr);

Diese Funktion löscht die durch »attr« spezifizierte Attributdatei aus dem zum Treiber »drv« gehörigen Verzeichnis im Sys-Filesystem.

driver_unregister

#include <linux/device.h>

void driver_unregister(struct device_driver *drv);

Die Funktion meldet den Treiber, der durch »drv« repräsentiert ist, beim Gerätemodell ab.

elv_next_request

#include <linux/elevator.h>

struct request *elv_next_request(request_queue_t *q);

Die Funktion dient einem Blockgerätetreiber dazu, aus der Request-Queue »q« den nächsten Request zu entnehmen.

Rückgabewert. Die Funktion gibt jeweils einen Zeiger auf den nächsten Auftrag (struct request *) zurück.

end_request

#include <linux/blockdev.h>

void end_request(struct request *req, int uptodate);

Diese Funktion wird innerhalb eines Blockgerätetreibers aufgerufen, sobald der Auftrag »req« beendet wurde. Der Parameter »uptodate« dient dazu, dem Blockgeräte-Subsystem mitzuteilen, ob eine Bearbeitung des Requests »req« stattgefunden hat (uptodate≠0) oder nicht (uptodate==0).

EXPORT_SYMBOL

#include <linux/module.h>

EXPORT_SYMBOL(sym);

Das Makro dient dazu, die Adresse der Variablen oder der Funktion »sym« außerhalb des Moduls (des Quelltextes), in dem die Variable oder Funktion definiert ist, bekannt zu geben. Auf das so exportierte Symbol kann von jeder anderen Kernelkomponente aus zugegriffen werden.

EXPORT_SYMBOL_GPL

#include <linux/module.h>

EXPORT_SYMBOL_GPL(sym);

Das Makro dient dazu, die Adresse der Variablen oder der Funktion »sym« außerhalb des Moduls (Quelltextes), in dem die Variable oder Funktion definiert ist, bekannt zu geben. Auf das so exportierte Symbol kann allerdings nur von den Komponenten aus zugegriffen werden, die unter der GPL oder einer verwandten Lizenz stehen (siehe Funktion MODULE_LICENSE und Abschnitt Nicht vergessen: Auswahl einer geeigneten Lizenz).

flush_scheduled_work

#include <linux/workqueue.h>

void flush_scheduled_work(void);

Die Funktion erzwingt die Abarbeitung der zum Zeitpunkt des Funktionsaufrufes der Event-Workqueue übergebenen Funktionen und blockiert, bis die Abarbeitung derselben abgeschlossen ist.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_work, queue_delayed_work, schedule_work und schedule_delayed_work.

flush_workqueue

#include <linux/workqueue.h>

void flush_workqueue(struct workqueue_struct *wq);

Die Funktion erzwingt die Abarbeitung der in der Workqueue »wq« zum Zeitpunkt des Funktionsaufrufes eingehängten Funktionen und blockiert, bis die Abarbeitung derselben abgeschlossen ist.

Siehe auch: create_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_work, queue_delayed_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

free_dma

#include <asm/dma.h>

void free_dma(unsigned int dmanr);

Über diese Funktion wird der durch den Parameter »dmanr« spezifizierte DMA-Kanal freigegeben.

free_irq

#include <linux/interrupt.h>

void free_irq(unsigned int irq, void *dev_id);

Über diese Funktion wird die durch die Parameter »irq« und »dev_id« eindeutig spezifizierte Ressource wieder freigegeben. Falls während des Aufrufes die zugehörige ISR aktiv ist, wartet die Funktion das Ende der ISR ab, bevor sie zum Aufrufer zurückkehrt. Die Funktion darf nicht im Interrupt-Kontext aufgerufen werden.

free_netdev

#include <linux/netdevice.h>

void free_netdev(struct net_device *dev);

Die Funktion löst die Referenz auf das Netzwerkgerät-Objekt »dev«. Falls es sich um die letzte Referenz handelt, wird das Objekt freigegeben. Mit alloc_netdev möglicherweise zusätzlich reservierter Speicher für private Daten wird ebenfalls freigegeben. Hat aber die Applikation selbst Speicher für private Daten, die mit »dev« verknüpft sind, reserviert, muss die Applikation den Speicher ebenfalls selbst wieder freigeben.

get_cycles

#include <asm/timex.h>

cycles_t get_cycles(void);

Diese Inline-Funktion ruft die Funktion rdtscll auf.

Rückgabewert. Die Funktion gibt den Wert des Taktzyklenzählers zurück. Der Typ cycles_t entspricht auf einer x86-Architektur einem unsigned long long.

Siehe auch: rdtsc, rdtscl, rdtscll.

get_user

#include <asm/uaccess.h>

int get_user(variable, source);

Die Funktion liest von der Adresse »source« einen Wert in die Variable »variable«. Der Wert kann 1, 2, 4 oder 8 Byte haben, abhängig vom Datentyp des Parameters »source«. Vor dem Datentransfer wird die Gültigkeit des Parameters »source« verifiziert.

Die Funktion kann die zugehörige Treiberinstanz schlafen legen.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen (negative) Fehlercode (»-EFAULT«) zurück.

imajor

#include <linux/fs.h>

int imajor(struct inode *device_file);

Das Makro gibt die Major-Nummer der Gerätedatei »device_file« zurück.

Rückgabewert. Das Makro gibt die Majornumber zurück.

iminor

#include <linux/fs.h>

int iminor(struct inode *device_file);

Das Makro gibt die zur Gerätedatei »device_file« gehörige Minor-Nummer zurück.

Rückgabewert. Das Makro gibt die Minornumber zurück.

in[bwl]

#include <asm/io.h>

u8 inb(int port);

u16 inw(int port);

u32 inl(int port);

Die Makros lesen vom Port »port« jeweils ein, zwei oder vier Byte ein.

Rückgabewert. Die Funktionen geben den Wert an der gelesenen IO-Adresse zurück.

in[bwl]_p

#include <asm/io.h>

u8 inb_p(int port);

u16 inw_p(int port);

u32 inl_p(int port);

Die Makros lesen vom Port »port« ein, zwei bzw. vier Byte ein und machen danach eine kurze Pause.

Rückgabewert. Die Funktionen geben den Wert an der gelesenen IO-Adresse zurück.

init_completion

#include <linux/completion.h>

void init_completion(struct completion *x);

Die Inline-Funktion ist für die dynamische Initialisierung des Completion-Objekts »x« zuständig. Das Objekt kann mit Hilfe von DECLARE_COMPLETION auch statisch definiert werden.

Siehe auch: DECLARE_COMPLETION, complete, complete_all, complete_and_exit und wait_for_completion.

INIT_LIST_HEAD

#include <linux/list.h>

INIT_LIST_HEAD(struct list_head *list_object);

Das Makro initialisiert das Listenobjekt »list_object« (dynamische Initialisierung).

Siehe auch: LIST_HEAD, list_add, list_del, list_for_each_entry_safe, list_entry und list_for_each_safe.

init_MUTEX

#include <linux/wait.h>

void init_MUTEX(struct semaphore *sema);

Die Inline-Funktion initialisiert das Mutex »sema«. Der kritische Abschnitt wird dadurch nicht betreten, das Mutex bleibt frei (ungesperrt).

init_MUTEX_LOCKED

#include <asm/semaphore.h>

void init_MUTEX_LOCKED(struct semaphore *sema);

Die Inline-Funktion initialisiert das Mutex »sema« und sperrt es gleichzeitig.

init_rwsem

#include <asm/rwsem.h>

void init_rwsem(struct rw_semaphore *sem);

Die Funktion dient zur Initialisierung des Lese-/Schreib-Semaphor »sem«.

Siehe auch: init_rwsem, down_read, down_write, down_read_trylock, down_write_trylock, downgrade_write, up_read und up_write.

init_timer

#include <linux/timer.h>

void init_timer(struct timer_list *timer);

Über diese Inline-Funktion wird die Datenstruktur »timer« initialisiert. Sie muss aufgerufen werden, bevor eine der anderen Timerfunktionen aufgerufen wird.

init_waitqueue_head

#include <linux/wait.h>

void init_waitqueue_head(waitqueue_head_t *q);

Über diese Inline-Funktion wird die Waitqueue »q« initialisiert.

INIT_WORK

#include <linux/workqueue.h>

INIT_WORK(struct work_struct *_work, void (*_func)(void *), void *_data);

Mit diesem Makro wird die Struktur »_work« initialisiert. »_func« ist die Funktion, die im Rahmen der Workqueue abgearbeitet wird, »_data« sind die Daten, die der Funktion dabei übergeben werden.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, DECLARE_WORK, queue_work, queue_delayed_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

ins[bwl]

#include <asm/io.h>

void insb(int port, void *addr, unsigned long count);

void insw(int port, void *addr, unsigned long count);

void insl(int port, void *addr, unsigned long count);

Die Makros lesen »count« Mal vom angegebenen Port jeweils ein, zwei bzw. vier Byte ein und schreiben diese ab der Adresse »addr« in den Speicher.

isalpha

#include <linux/ctype.h>

unsigned char isalnum(unsigned char c);

unsigned char isalpha(unsigned char c);

unsigned char iscntrl(unsigned char c);

unsigned char isdigit(unsigned char c);

unsigned char isgraph(unsigned char c);

unsigned char islower(unsigned char c);

unsigned char isprint(unsigned char c);

unsigned char ispunct(unsigned char c);

unsigned char isspace(unsigned char c);

unsigned char isupper(unsigned char c);

unsigned char isxdigit(unsigned char c);

unsigned char isascii(unsigned char c);

Die Makros überprüfen, ob »c« zu einer spezifischen Zeichenklasse gehört oder nicht.

isalnum

überprüft, ob »c« zur Klasse der Alphanumerischen Zeichen (Buchstaben und Ziffern) gehört.

isalpha

überprüft, ob »c« zur Klasse der Buchstaben (alphabetisches Zeichen) gehört.

iscntrl

überprüft, ob »c« zur Klasse der Kontrollzeichen gehört.

isdigit

überprüft, ob »c« zur Klasse der Ziffern gehört.

isgraph

überprüft, ob »c« zur Klasse der druckbaren Zeichen – mit Ausnahme des Leerzeichens (Space) – gehört.

islower

überprüft, ob »c« ein Kleinbuchstabe ist.

isprint

überprüft, ob »c« zur Klasse der druckbaren Zeichen (inklusive des Leerzeichens) gehört.

ispunct

überprüft, ob »c« zur Klasse der druckbaren Zeichen – ausgenommen sind allerdings alle Buchstaben und Ziffern – gehört.

isspace

überprüft, ob »c« ein »weißes« Leerzeichen ist (Leerzeichen, Tab, Formfeed ...).

isupper

überprüft, ob es sich bei »c« um einen Großbuchstaben handelt.

isxdigit

überprüft, ob »c« zur Klasse der Zeichen gehört, mit denen ein Hexadezimalwert dargestellt werden kann (0-9, a-f, A-F).

isascii

überprüft, ob »c« zur Klasse der ASCII-Zeichen gehört.

Rückgabewert. Falls »c« zur angegebenen Zeichenklasse gehört, wird »nicht 0« zurückgegeben, ansonsten »0«.

jiffies_to_timespec

#include <linux/time.h>

void jiffies_to_timespec(unsigned long jiffies, struct timespec *value);

Die Inline-Funktion konvertiert die übergebenen »jiffies« in Sekunden und Nanosekunden und legt das Ergebnis in »value« ab. Die struct timespec ist in der Header-Datei <linux/time.h> deklariert:

struct timespec {
    time_t tv_sec;  /* seconds (long) */
    long   tv_nsec; /* nanoseconds */
};

jiffies_to_timeval

#include <linux/time.h>

void jiffies_to_timeval(unsigned long jiffies, struct timeval *value);

Die Inline-Funktion konvertiert die übergebenen »jiffies« in Sekunden und Mikrosekunden (»value«). Die struct timeval ist ebenfalls in der Header-Datei <linux/time.h> deklariert:

struct timeval {
    time_t      tv_sec;  /* seconds (long) */
    suseconds_t tv_usec; /* microseconds (long) */
};

kernel_thread

#include <asm/processor.h>

int kernel_thread(int (*fn)(void *),, void *arg, unsigned long flags);

Mit dieser Funktion wird ein neuer Kernel-Thread erzeugt. Der Thread arbeitet die Funktion »fn« ab, der das Argument »arg« übergeben wird. Über »flags« lässt sich der Thread parametrieren:

Rückgabewert. Die Funktion gibt im Erfolgsfall die Prozess-ID (PID) des neu erzeugten Threads zurück. Ein Fehler ist aufgetreten, falls die Funktion einen negativen Wert zurückgibt.

kfree

#include <linux/wait.h>

void kfree(const void *objp);

Über diese Funktion wird der per kmalloc im Kernel allozierte Speicher »objp« wieder freigegeben.

kill_proc

#include <linux/sched.h>

int kill_proc(pid_t pid, int sig, int priv);

Mit dieser Funktion wird dem durch »pid« spezifizierten Prozess das Signal mit der Nummer »sig« geschickt. Der Parameter »priv« muss innerhalb des Kernels auf den Wert »1« gesetzt werden, damit Überprüfungen der Zugriffsberechtigung unterbleiben. Ist »priv« nämlich »0«, geht der Kernel davon aus, dass das Signal von einem User-Prozess erzeugt wurde.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten einen Fehlercode zurück.

kmalloc

#include <linux/slab.h>

void *kmalloc(size_t size, int flags);

Über diese Funktion kann vom Kernel dynamisch Speicher der Länge »size« alloziert werden. Über die Flags »flags« wird der Zugriff gesteuert. Insbesondere die Flags (deklariert in <linux/mm.h>) »GFP_KERNEL«, »GFP_USER« und »GFP_ATOMIC« sind interessant. »GFP_KERNEL« und »GFP_USER« erlauben dem Kernel, die zugehörige Treiberinstanz (»GFP_USER«) bzw. Kernelfunktion (»GFP_KERNEL«) »schlafen« zu legen, falls kein Speicher zur Verfügung steht. Damit ist die Verwendung dieses Flags nur im Prozess-Kontext möglich.

»GFP_ATOMIC« ist die Variante, bei der kmalloc die Treiberinstanz nicht schlafen legt. Diese Variante kann daher auch im Interrupt-Kontext des Treibers verwendet werden.

Rückgabewert. Die Funktion gibt »NULL« zurück, falls kein Speicher zur Verfügung steht, ansonsten die Startadresse des allozierten Speicherbereichs.

kobject_set_name

#include <linux/kobject.h>

int kobject_set_name(struct kobj *kernel_object, char *format, ...);

Die Funktion setzt den Namen des Kernel-Objektes »kernel_object« gemäß der übergebenen Parameter und des Formatstrings »format«.

Rückgabewert. Im Erfolgsfall gibt die Funktion »0« zurück, ansonsten »-ENOMEM« oder »-EFAULT«.

list_add

#include <linux/list.h>

void list_add(struct list_head *new, struct list_head *head);

Die Inline-Funktion hängt das Element »new« hinter das Element »head« ein.

Siehe auch: LIST_HEAD, INIT_LIST_HEAD, list_del, list_for_each_entry_safe, list_entry und list_for_each_safe.

list_del

#include <linux/list.h>

void list_del(struct list_head *entry);

Die Inline-Funktion löscht das Element »entry« aus der Liste.

Siehe auch: LIST_HEAD, INIT_LIST_HEAD, list_add, list_for_each_entry_safe, list_entry und list_for_each_safe.

list_entry

#include <linux/list.h>

void list_entry(struct list_head *ptr, type, member);

Das Makro gibt die Adresse des Elementes »member« der Datenstruktur vom Typ »type« der Liste »ptr« zurück.

Siehe auch: LIST_HEAD, INIT_LIST_HEAD, list_add, list_del, list_for_each_entry_safe und list_for_each_safe.

list_for_each_safe

#include <linux/list.h>

void list_for_each_safe(struct list_head *pos, struct list_head *n, struct list_head *head);

Das Makro erlaubt den Zugriff auf die einzelnen Listenelemente der durch »head« gegebenen Liste. Es stellt den Kopf einer for-Schleife dar, die in »pos« den aktuellen Listenzeiger enthält. »n« wird intern als temporärer Speicher benötigt. Um aufgrund des Listenzeigers an die eigentliche Datenstruktur zu gelangen, muss noch das Makro list_entry eingesetzt werden. Allerdings kann auch direkt die Variante list_for_each_entry_safe genutzt werden. Dann enthält »pos« die Adresse der eigentlich gesuchten Datenstruktur.

Siehe auch: LIST_HEAD, INIT_LIST_HEAD, list_add, list_del, list_for_each_entry_safe und list_entry.

list_for_each_entry_safe

#include <linux/list.h>

void list_for_each_entry_safe(pos, struct list_head *n, struct list_head *head, member);

Das Makro erlaubt den Zugriff auf die einzelnen Listenelemente der durch »head« gegebenen Liste. Es stellt den Kopf einer for-Schleife dar, die in »pos« die Adresse der gesuchten Datenstruktur hat. »n« wird intern als temporärer Speicher benötigt.

Siehe auch: LIST_HEAD, INIT_LIST_HEAD, list_add, list_del, list_entry und list_for_each_safe.

LIST_HEAD

#include <linux/list.h>

LIST_HEAD(struct list_head name);

Das Makro definiert ein Listenobjekt mit dem Namen »name« (statische Initialisierung).

Siehe auch: INIT_LIST_HEAD, list_add, list_del, list_for_each_entry_safe, list_entry und list_for_each_safe.

local_bh_disable

#include <linux/interrupt.h>

void local_bh_disable(void);

Durch Aufruf dieser Funktion wird verhindert, dass auf der lokalen CPU ein Softirq abgearbeitet wird. Auf den anderen Mikroprozessoren eines SMP-Systems können Softirqs weiterhin bearbeitet werden.

local_bh_enable

#include <linux/interrupt.h>

void local_bh_enable(void);

Durch Aufruf dieser Funktion wird die Bearbeitung von Softirqs auf der lokalen CPU wieder freigegeben.

local_irq_disable

#include <asm/system.h>

void local_irq_disable(void);

Das Makro gibt den Interrupt auf der lokalen CPU frei.

local_irq_enable

#include <asm/system.h>

void local_irq_enable(void);

Das Makro sperrt den Interrupt auf der lokalen CPU.

lock_kernel

#include <linux/smp_lock.h>

void lock_kernel(void);

Die Inline-Funktion reserviert den »großen Kernel-Lock«. Der Kernel-Lock ist ein globales Spinlock zum Schutz kritischer Abschnitte innerhalb des Kernels. Er sollte nur in absoluten Ausnahmefällen Anwendung finden.

MAJOR

#include <linux/kdev_t.h>

unsigned int MAJOR(dev_t device_number);

Das Makro berechnet aus der übergebenen Gerätenummer »device_number« die zugehörige Major-Nummer.

Rückgabewert. Das Makro gibt die Major-Nummer zurück.

mb

#include <asm/system.h>

void mb(void);

Memory Barrier: Vor dem nächsten Schreib- oder Leseauftrag werden sämtliche bisher angestoßenen Schreib- oder Leseaufträge abgearbeitet.

Siehe auch: wmb, rmb und barrier.

mdelay

#include <linux/delay.h>

void mdelay(long milliseconds);

Dieses Makro verzögert den Ablauf des Prozesses bzw. des Treibers um die im Feld »milliseconds« angegebenen Millisekunden. Die Verzögerung wird durch aktives Warten (Busy-Loop) erreicht und sollte

  1. möglichst vermieden werden und

  2. grundsätzlich nicht über längere Zeit durchgeführt werden.

memcpy

#include <asm/io.h>

void *memcpy(void *dest, int src, size_t n);

Die Funktion kopiert »n« Bytes ab der Speicheradresse »src« an die Adresse »dest«. Die Speicherbereiche dürfen nicht überlappen. Sollen Daten aus dem Hauptspeicher an ein in den Speicherbereich gemapptes Peripheriegerät kopiert werden, ist anstelle von memcpy die Funktion memcpy_toio, bzw. falls Daten von einem in den Speicherbereich gemappten Peripheriegerät in den Hauptspeicher kopiert werden sollen, die Funktion memcpy_fromio zu verwenden.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Speicherbereich »dest« zurück.

memcpy_fromio

#include <asm/io.h>

void *memcpy_fromio(void *dest, const void *src, size_t n);

Die Funktion kopiert »n« Bytes ab dem Speicherbereich »src« des Peripheriegerätes an die Speicheradresse »dest«. Die Speicherbereiche dürfen nicht überlappen.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Speicherbereich »dest« zurück.

memcpy_toio

#include <asm/io.h>

void *memcpy_toio(void *dest, int src, size_t n);

Die Funktion kopiert »n« Bytes ab der Hauptspeicheradresse »src« an den Speicherbereich des Peripheriegerätes »dest«. Die Speicherbereiche dürfen nicht überlappen.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Speicherbereich »dest« zurück.

memset

#include <asm/io.h>

void *memset(void *s, int c, size_t n);

Die Funktion füllt die ersten »n« Bytes des Speicherbereiches, der durch »s« gegeben ist, mit dem konstanten (Byte-)Wert »c«. Sollen Bereiche eines in den Hauptspeicher eingeblendeten Peripheriegerätes mit einem konstanten Wert belegt werden, ist statt dieser Funktion die Funktion memset_io zu verwenden.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Speicherbereich »s« zurück.

memset_io

#include <asm/io.h>

void *memset_io(void *s, int c, size_t n);

Die Funktion füllt die ersten »n« bytes des Speicherbereich »s« eines Peripheriegerätes, welches in den Speicherbereich des Rechners eingeblendet ist, mit dem konstanten (Byte-)Wert »c«.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Speicherbereich »s« zurück.

MINOR

#include <linux/kdev_t.h>

unsigned int MINOR(dev_t device_number);

Das Makro berechnet aus der übergebenen Gerätenummer »device_number« die zugehörige Minor-Nummer.

Rückgabewert. Das Makro gibt die Minor-Nummer zurück.

MKDEV

#include <linux/kdev_t.h>

dev_t MKDEV(unsigned int ma, unsigned int mi);

Das Makro MKDEV erzeugt aus der Major-Nummer »ma« und der Minor-Nummer »mi« eine Gerätenummer, die kernelinterne Repräsentierung dieser Gerätekennung.

Rückgabewert. Gerätenummer.

mod_timer

#include <linux/timer.h>

int mod_timer(struct timer_list *timer, unsigned long expires);

Der Aufrufzeitpunkt des Timers »timer« wird auf den neuen Wert »expires« gesetzt. Sobald ein Timer aktiviert ist, kann der Aufrufzeitpunkt nicht mehr – ohne diese Funktion – direkt manipuliert werden. Wird diese Funktion aufgerufen und der Timer »timer« ist noch nicht aktiviert, wird der Timer aktiviert.

Rückgabewert. Wenn ein aktiver Timer modifiziert wurde, gibt die Funktion »1« zurück, ansonsten »0«.

MODULE_DEVICE_TABLE

#include <linux/module.h>

MODULE_DEVICE_TABLE(subsystem, tabelle);

Um zu einem Gerät automatisch den passenden Treiber zu finden, werden aus dem Treiber heraus alle Kennungen in Tabellen abgelegt. Der Treiber macht die Tabelle mit den Kennungen über das Makro MODULE_DEVICE_TABLE bekannt. Der Parameter »subsystem« kennzeichnet das Subsystem. Die folgenden Subsysteme stehen zur Auswahl: »pci«, »usb«, »isapnp«, »parisc«, »ccw« (S390), »input«, »pnp«, »pnp_card« (Sound) und »ieee1394«. Der Parameter »tabelle« kennzeichnet die Datenstruktur, die die Kennungen enthält, für die der Treiber zuständig ist.

module_exit

#include <linux/init.h>

module_exit(name);

Das Makro module_exit bekommt mit dem Parameter »name« den Namen der Deinitialisierungsfunktion übergeben. Damit wird die korrekte Übersetzung des Codes entweder als Kernel- oder als Modultreiber gesteuert. Wird der Treiber als Modul übersetzt, expandiert das Makro die Deinitialisierungsfunktion zu cleanup_module. Wird der Treiber zum Built-in-Treiber übersetzt, wird der Name der Deinitialisierungsfunktion so expandiert, dass sie beim Runterfahren des Kernels aufgerufen wird.

module_init

#include <linux/init.h>

module_init(name);

Das Makro module_init bekommt als Parameter »name« den Namen der Treiberinitialisierungsfunktion übergeben. Damit wird die korrekte Übersetzung des Codes entweder als Kernel- oder als Modultreiber gesteuert. Wird der Treiber als Modul übersetzt, expandiert das Makro die Initialisierungsfunktion zu init_module. Wird der Treiber zum Built-in-Treiber übersetzt, wird die Initialisierungsfunktion so expandiert, dass sie beim Booten des Kernels aufgerufen wird.

MODULE_LICENSE

#include <linux/module.h>

MODULE_LICENSE(lizenz);

Das Makro MODULE_LICENSE bekommt mit dem Parameter »lizenz« den Namen der für das Modul gültigen Lizenz übergeben. Nur wenn das Modul unter eine GPL-artige Lizenz gestellt wird, stehen ihm sämtliche Funktionen des Kernels zur Verfügung. Mögliche Werte für »lizenz« sind:

module_param

#include <linux/moduleparam.h>

module_param(var, type, perm);

Mit Hilfe dieses Makros wird der Parameter mit dem Namen »var« vom Typ »type« dem Kernel bekannt gegeben. Im Modul muss dazu eine Variable mit Namen »var« definiert sein. Der Parameter »type« kann die Werte »short«, »ushort«, »int«, »uint«, »long«, »ulong«, »charp«, »bool« und »invbool« annehmen. Falls ein eigener Parameter vom Typ »XXX« definiert wurde, ist der Typ »XXX« ebenfalls einsetzbar.

Der Parameter »perm« definiert die Zugriffsrechte (nach bekannter Unix-Konvention) der Parameterdatei, die vom Gerätemodell im Sys-Filesystem angelegt wird (in Kernelversion 2.6.3 noch nicht implementiert).

module_param_array

#include <linux/moduleparam.h>

module_param_array(name, type, int num, perm);

Dieses Makro ist für die Parameterübergabe von Feldern zuständig. Der Parameter »name« spezifiziert den Parameternamen, »type« den Parametertyp (siehe module_param), »num« eine Variable, die die Anzahl der Feldelemente enthält und »perm« die Zugriffsrechte der zugehörigen Datei im Sys-Filesystem. Im Kernel 2.6.3 ist die Unterstützung des Sys-Filesystems noch nicht implementiert.

module_param_named

#include <linux/moduleparam.h>

module_param_named(name, value, type, perm);

Das Makro hat die gleiche Funktion wie module_param mit dem einzigen Unterschied, dass der Name der im Modul verwendeten Variablen nicht mit dem Parameternamen übereinstimmen muss. Der Name der Variablen ist mit »value« gegeben, der Name des Parameters mit »name«

module_param_string

#include <linux/moduleparam.h>

module_param_string(name, string, len, perm);

Dieses Makro ist für die Parameterübergabe von Strings zuständig. »name« ist der Name des Parameters, »string« ist der Name des Zeichenfeldes, »len« gibt die Länge des Zeichenfeldes an und »perm« schließlich die Zugriffsrechte der zugehörigen Datei im Sys-Filesystem. Der Sys-Filesystem-Support ist in Kernel 2.6.3 noch nicht implementiert.

MODULE_PARM_DESC

#include <linux/module.h>

MODULE_PARM_DESC(var, desc);

Das Makro ordnet der Variablen »var« den beschreibenden String »desc« zu. Die Beschreibung wird ausgegeben, falls die Modulinformationen mittels des Programms modinfo angefordert werden.

module_put

#include <linux/module.h>

void module_put(struct module *module);

Die Inline-Funktion dekrementiert den Referenzzähler des Moduls »module«. Solange der Referenzzähler größer als »0« ist, kann das Modul nicht entladen werden. Normalerweise wird der Referenzzähler des Moduls automatisch durch den Kernel erhöht.

Siehe auch: try_module_get und request_module.

netif_queue_stopped

#include <linux/netdevice.h>

int netif_queue_stopped(const struct net_device *dev);

Diese Funktion testet, ob der Treiber »dev« gegenwärtig in der Lage ist, Pakete anzunehmen oder nicht.

Rückgabewert. Die Funktion gibt »0« zurück, falls das Interface Pakete entgegennehmen kann, respektive einen Wert ungleich »0« (True), falls das Interface gestoppt ist.

netif_rx

#include <linux/netdevice.h>

int netif_rx(struct sk_buff *skb);

Ein Treiber übergibt das empfangene Paket »skb« mit Hilfe dieser Funktion dem Netzwerk-Subsystem zur Weiterverarbeitung. Die oberen Protokollschichten können bei hoher Last das Paket verwerfen.

Rückgabewert. Die Rückgabewerte der Funktion sind die folgenden:

netif_start_queue

#include <linux/netdevice.h>

void netif_start_queue(struct net_device *dev);

Diese Inline-Funktion zeigt der übergelagerten Protokoll-Schicht, die für das Verteilen der Pakete auf den durch den Parameter »dev« gekennzeichneten Treiber zuständig ist, an, dass der Treiber Pakete (Aufträge) entgegennehmen kann. Normalerweise wird die Funktion während der Treiber-Open-Funktion (aufgrund eines ifconfig up Kommandos auf Applikationsebene) aufgerufen.

netif_stop_queue

#include <linux/netdevice.h>

void netif_stop_queue(struct net_device *dev);

Über diese Inline-Funktion wird dem Queueing-Layer signalisiert, dass der durch »dev« gekennzeichnete Treiber gegenwärtig keine weiteren Pakete annehmen kann. Meist wird die Funktion während des Sendens von Paketen oder beim Treiber-Close aufgerufen. Die Signalisierung, dass Pakete wieder angenommen werden können, wird durch die Funktion netif_wake_queue durchgeführt.

netif_wake_queue

#include <linux/netdevice.h>

void netif_wake_queue(struct net_device *dev);

Über diese Inline-Funktion wird dem Queueing-Layer signalisiert, dass der durch den Parameter »dev« spezifizierte Treiber wieder Pakete annehmen kann.

out[bwl]

#include <asm/io.h>

void outb(u8 value, int port);

void outw(u16 value, int port);

void outl(u32 value, unsigned short port);

Die Makros schreiben auf den Port »port« den Wert »value«.

out[bwl]_p

#include <asm/io.h>

void outb_p(u8 value, int port);

void outw_p(u16 value, int port);

void outl_p(u32 value, int port);

Das Makro schreibt auf den Port »port« den Wert »value« und macht danach eine kurze Pause.

outs[bwl]

#include <asm/io.h>

void outsb(int port, void *addr, unsigned long count);

void outsw(int port, void *addr, unsigned long count);

void outsl(int port, void *addr, unsigned long count);

Die Makros schreiben auf den Port »port« »count« Mal die ab der Adresse »addr« beginnenden 8-, 16- bzw. 32-Bit-Wörter.

pci_enable_device

#include <linux/pci.h>

int pci_enable_device(struct pci_dev *dev);

Über diese Funktion wird das Gerät »dev« eingeschaltet.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen Fehlercode zurück.

pci_module_init

#include <linux/pci.h>

int pci_module_init(struct pci_driver *drv);

Diese Inline-Funktion registriert mittels pci_register_driver den Treiber »drv« beim PCI-Subsystem. Ist jedoch keine Hardware vorhanden und werden vom Kernel keine »Hotpluggable«-Devices unterstützt, wird der Treiber mittels pci_unregister_driver wieder abgemeldet.

Rückgabewert. Anders als pci_register_driver gibt die Funktion »0« zurück, falls der Treiber erfolgreich beim PCI-Subsystem angemeldet werden konnte. Im Fehlerfall gibt die Funktion »-ENODEV« zurück.

pci_read_config_byte

#include <linux/pci.h>

int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val);

Die Funktion liest aus dem Konfigurationsspeicher des durch »dev« angegebenen PCI-Gerätes ein 8-Bit-Wort ab dem Offset »where«. Dieses Wort wird an die durch »val« angegebene Adresse abgespeichert.

Rückgabewert. Die Funktion gibt die Anzahl der gelesenen Bytes zurück.

pci_read_config_dword

#include <linux/pci.h>

int pci_read_config_dword(struct pci_dev *dev, int where, u32 *val);

Die Funktion liest aus dem Konfigurationsspeicher des durch »dev« angegebenen PCI-Gerätes ein 32-Bit-Wort ab dem Offset »where«. Dieses Wort wird an die durch »val« angegebene Adresse abgespeichert.

Rückgabewert. Die Funktion gibt die Anzahl der gelesenen Bytes zurück.

pci_read_config_word

#include <linux/pci.h>

int pci_read_config_word(struct pci_dev *dev, int where, u16 *val);

Die Funktion liest aus dem Konfigurationsspeicher des durch »dev« angegebenen PCI-Gerätes ein 16-Bit-Wort ab dem Offset »where«. Dieses Wort wird an die durch »val« angegebene Adresse abgespeichert.

Rückgabewert. Die Funktion gibt die Anzahl der gelesenen Bytes zurück.

pci_register_driver

#include <linux/pci.h>

int pci_register_driver(struct pci_driver *drv);

Diese Funktion meldet den durch »drv« repräsentierten Treiber beim PCI-Subsystem an.

Rückgabewert. Die Funktion gibt die Anzahl der Geräte (Boards) zurück, die der Treiber während der Initialisierung beansprucht hat.

pci_resource_end

#include <linux/pci.h>

unsigned long pci_resource_end(struct pci_dev *dev, int bar);

Über dieses Makro wird das Ende des durch »bar« angegebenen IO- oder Speicherbereichs des PCI-Gerätes »dev« zurückgegeben.

Rückgabewert. Die Funktion gibt die Endadresse des IO- oder Speicherbereiches zurück.

pci_resource_flags

#include <linux/pci.h>

unsigned long pci_resource_flags(struct pci_dev *dev, int bar);

Über dieses Makro werden die Flags des durch »bar« angegebenen IO- oder Speicherbereichs des PCI-Gerätes »dev« zurückgegeben.

Rückgabewert. Die Funktion gibt die Flags des IO- oder Speicherbereiches zurück.

pci_resource_len

#include <linux/pci.h>

unsigned long pci_resource_len(struct pci_dev *dev, int bar);

Über dieses Makro wird die Länge des durch »bar« angegebenen IO- oder Speicherbereichs des PCI-Gerätes »dev« zurückgegeben.

Rückgabewert. Die Funktion gibt die Länge des IO- oder Speicherbereiches zurück.

pci_resource_start

#include <linux/pci.h>

unsigned long pci_resource_start(struct pci_dev *dev, int bar);

Über dieses Makro wird der Inhalt des durch »bar« angegebenen Base Address Registers des PCI-Gerätes »dev« ausgelesen.

Rückgabewert. Das Makro gibt die Startadresse der Ressource zurück.

pci_unregister_driver

#include <linux/pci.h>

void pci_unregister_driver(struct pci_driver *drv);

Über diese Funktion meldet sich der durch »drv« repräsentierte Treiber beim PCI-Subsystem ab. Das PCI-Subsystem ruft daraufhin die Remove-Funktion des Treibers auf.

platform_device_register

#include <linux/device.h>

int platform_device_register(struct platform_device *pdev);

Der Platformbus dient als Container für Geräte, die nicht über ein standardisiertes Bussystem angekoppelt sind. Mit Hilfe dieser Funktion wird das Platform-Gerät »pdev« dem Gerätemodell übergeben.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück, ansonsten einen negativen Fehlercode.

platform_device_unregister

#include <linux/device.h>

void platform_device_unregister(struct device *dev);

Mit Hilfe dieser Funktion wird das zuvor über die Funktion platform_device_register angemeldete Platform-Gerät »dev« wieder abgemeldet.

poll_wait

#include <linux/poll.h>

void poll_wait(struct file *instance, wait_queue_head_t *wait_address, poll_table *p);

Über diese Inline-Funktion teilt der Treiber dem Kernel die Wait-Queue (»wait_address«) mit, auf die sich der Treiber schlafen legt, bis Daten entweder zum Lesen vorhanden sind oder Daten geschrieben werden können. Die Funktion wird normalerweise innerhalb der Funktion driver_poll aufgerufen. Dabei werden die Parameter »instance« und »p« an poll_wait durchgereicht.

static unsigned int busmouse_poll(struct file *file, poll_table *wait)
{
    struct busmouse_data *mse = (struct busmouse_data *)file->private_data;

    poll_wait(file, &mse->wait, wait);
    if (mse->ready)
        return POLLIN | POLLRDNORM;
    return 0;
}

pr_debug

#include <linux/kernel.h>

int pr_debug(const char *fmt, ...);

Alternativ zu printk kann zu Debug-Zwecken auch dieses Makro verwendet werden. Es sorgt dafür, dass der Syslog-Level auf KERN_DEBUG gesetzt wird. Außerdem werden im Code nur dann überhaupt Ausgaben erzeugt, wenn der Kernel mit dem Define »DEBUG« kompiliert wurde.

Rückgabewert. Die Funktion gibt die Anzahl der ausgegebenen Zeichen zurück.

pr_info

#include <linux/kernel.h>

int pr_info(const char *fmt, ...);

Alternativ zu printk kann zu Debug-Zwecken auch dieses Makro verwendet werden. Es sorgt dafür, dass der Syslog-Level auf KERN_INFO gesetzt wird.

Rückgabewert. Die Funktion gibt die Anzahl der ausgegebenen Zeichen zurück.

printk

#include <linux/kernel.h>

int printk(const char *fmt, ...);

Die Funktion gibt einen Text, der mit Hilfe von »fmt« formatiert wird, über den Syslog-Mechanismus aus. Die Funktionalität ist prinzipiell angelehnt an die bekannte Funktion printf.

Falls die ersten drei Zeichen des Formatstrings »fmt« einem der Strings in der folgenden Tabelle gleichen, werden die Nachrichten gemäß der Syslog-Konfiguration mitprotokolliert:

String Bezeichnung Bedeutung
<0> KERN_EMERG System ist unbrauchbar.
<1> KERN_ALERT Es sind sofort Maßnahmen zu ergreifen.
<2> KERN_CRIT Kritische Zustände.
<3> KERN_ERR Fehlerhafte Zustände.
<4> KERN_WARNING Warnung.
<5> KERN_NOTICE Normaler, aber bedeutsamer Zustand.
<6> KERN_INFO Information.
<7> KERN_DEBUG Debug-Nachricht.

Siehe auch: pr_debug und pr_info.

Rückgabewert. Die Funktion gibt die Anzahl der ausgegebenen Zeichen zurück.

probe_irq_off

#include <linux/interrupt.h>

int probe_irq_off(unsigned long val);

Die Funktion ist Teil der automatischen Erkennung von Interrupts. Nach Start der Erkennung durch Aufruf von probe_irq_on und dem Auslösen eines Interrupts wird diese Funktion aufgerufen. Der Parameter »val« ist der Rückgabewert der Funktion probe_irq_on. Die Funktion überprüft die unbenutzten Interrupts und gibt die Nummer des Interrupts zurück, der den Interrupt wahrscheinlich ausgelöst hat.

Rückgabewert. Die Funktion gibt die Nummer des ausgelösten Interrupts zurück. Wurde kein Interrupt detektiert, gibt die Funktion »0« zurück. Wurden mehrere Interrupts gefunden, returniert sie einen negativen Wert.

probe_irq_on

#include <linux/interrupt.h>

unsigned long probe_irq_on(void);

Diese Funktion dient zur Vorbereitung der automatischen Erkennung einer Interruptleitung. Nach Aufruf der Funktion muss der Treiber einen Interrupt auslösen und danach die Funktion probe_irq_off aufrufen. probe_irq_off bekommt dabei den Rückgabewert dieser Funktion als Parameter übergeben.

Rückgabewert. Die Funktion gibt eine Maske der aktuell allozierten Interrupts zurück, im Fehlerfall »0«.

proc_mkdir

#include <linux/proc_fs.h>

struct proc_dir_entry *proc_mkdir(const char *dirname, struct proc_dir_entry *parent);

Die Funktion legt im durch »parent« spezifizierten Proc-Verzeichnis ein neues Unterverzeichnis mit dem Namen »dirname« an. Falls »parent« gleich »NULL« ist, wird das neue Unterverzeichnis im Root-Verzeichnis des Proc-Filesystems (meist /proc/) abgelegt.

Rückgabewert. Die Funktion gibt die Adresse des Objektes zurück, welches das neue Unterverzeichnis repräsentiert. Im Fehlerfall wird »NULL« zurückgegeben.

put_disk

#include <linux/genhd.h>

void put_disk(struct gendisk *disk);

Diese Funktion meldet das durch »disk« repräsentierte Blockgerät beim Blockgeräte-Subsystem ab.

put_user

#include <asm/uaccess.h>

int put_user(datum, destination);

Dieses Makro kopiert ein Byte, ein 2-Byte-Wort oder ein 4-Byte-Wort (»datum«) in den Speicherbereich einer Applikation an die Adresse »destination«.

Die Funktion kann die zugehörige Treiberinstanz schlafen legen.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen (negative) Fehlercode (»-EFAULT«) zurück.

queue_delayed_work

#include <linux/workqueue.h>

int queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay);

Die Funktion hängt »work« in die Workqueue »wq« ein. Die Workqueue sorgt dafür, dass die Funktion »work->func« in »delay«-Jiffies aufgerufen wird.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

Rückgabewert. Ein Rückgabewert von »0« zeigt einen Fehler an. Ein Wert ungleich »0« bedeutet, dass »work« erfolgreich in »wq« eingehängt werden konnte.

queue_work

#include <linux/workqueue.h>

int queue_work(struct workqueue_struct *wq, struct work_struct *work);

Die Funktion hängt »work« in die Workqueue »wq« ein. Die Workqueue sorgt dafür, dass die Funktion »work->func« zum nächstmöglichen Zeitpunkt aufgerufen wird.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_delayed_work, schedule_work, schedule_delayed_work und flush_scheduled_work.

Rückgabewert. Ein Rückgabewert von »0« zeigt einen Fehler an. Ein Wert ungleich »0« bedeutet, dass »work« erfolgreich in »wq« eingehängt werden konnte.

rdtsc

#include <asm/msr.h>

rdtsc(unsigned long low, unsigned long high);

Das Makro liest den Taktzyklenzähler aus und legt das niederwertige 32-Bit-Wort in die Variable »low« und das hochwertige 32-Bit-Wort in die Variable »high« ab.

Die Variablen »low« und »high« müssen vom Typ unsigned long sein.

Siehe auch: rdtscl, rdtscll, get_cycles.

rdtscl

#include <asm/msr.h>

rdtscl(unsigned long low);

Dieses Makro legt die niederwertigen 32 Bit des Taktzyklenregisters in eine Variable vom Typ long ab. Diese Funktionalität steht nicht auf jeder Hardware zur Verfügung!

    unsigned long tlow;
    ...
    if( cpu_has_tsc )
        rdtscl(tlow);

Siehe auch: rdtsc, rdtscll, get_cycles.

rdtscll

#include <asm/msr.h>

rdtscll(unsigned long long val);

Dieses Makro legt den Inhalt des Taktzyklenregisters in die Variable »val« vom Typ unsigned long long ab. Diese Funktionalität steht nicht auf jeder Hardware zur Verfügung!

    unsigned long long tall;
    ...
    if( cpu_has_tsc )
        rdtscll(tall);

Siehe auch: rdtsc, rdtscl, get_cycles.

read_lock

#include <linux/spinlock.h>

void read_lock(rwlock_t *lock);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Lesen. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion read_unlock verwendet werden.

read_lock_bh

#include <linux/spinlock.h>

void read_lock_bh(rwlock_t *lock);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Lesen und sperrt Softirqs. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Mit dieser Funktion kann ein kritischer Abschnitt geschützt werden, an dem Tasklets und Timer beteiligt sind. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion read_unlock_bh verwendet werden.

read_lock_irq

#include <linux/spinlock.h>

void read_lock_irq(rwlock_t *lock);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Lesen und sperrt Interrupts. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Mit dieser Funktion kann ein kritischer Abschnitt geschützt werden, an dem ISRs, Tasklets und Timer beteiligt sind. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion read_unlock_irq verwendet werden.

read_lock_irqsave

#include <linux/spinlock.h>

int read_lock_irqsave(rwlock_t *lock, unsigned int iflags);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Lesen, sichert die Interruptflags in »iflags« und sperrt Interrupts. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Mit dieser Funktion kann ein kritischer Abschnitt geschützt werden, an dem ISRs, Tasklets und Timer beteiligt sind. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion read_unlock_irqrestore verwendet werden.

read_seqbegin

#include <linux/seqlock.h>

unsigned read_seqbegin(const seqlock_t *sl);

Die Inline-Funktion speichert den Zählerwert des Sequence-Locks »sl« ab, so dass dieser nach einem erfolgten Zugriff auf die durch »sl« geschützte Variable mit Hilfe der Funktion read_seqretry verglichen werden kann.

Rückgabewert. Die Funktion gibt den Wert des Sequence-Lock-Zählers zurück.

read_seqbegin_irqsave

#include <linux/seqlock.h>

void read_seqbegin_irqsave(seqlock_t *sl, unsigned long iflags);

Die Inline-Funktion sichert die Interrupt-Flags in »iflags«, sperrt die Interrupts auf der lokalen CPU und sichert den Zählerwert des Sequence-Locks »sl«, so dass dieser nach einem erfolgten Zugriff auf die durch »sl« geschützte Variable mit Hilfe der Funktion read_seqretry_irqrestore verglichen werden kann.

Rückgabewert. Die Funktion gibt den Wert des Sequence-Lock-Zählers zurück.

read_seqretry

#include <linux/seqlock.h>

int read_seqretry(const seqlock_t *sl, unsigned iv);

Die Funktion dient dazu festzustellen, ob parallel zum Zugriff auf die durch »sl« geschützten Daten eine andere Instanz die Daten verändert hat. Ist das der Fall, muss der Zugriff wiederholt werden. »iv« enthält den per read_seqbegin aufgenommenen Zählerwert.

    unsigned seq;
    do {
        seq = read_seqbegin(&zeit_lock);
        ... // Hier erfolgt der lesende Zugriff auf die Daten
    } while( read_seqretry(&zeit_lock,seq) );

Rückgabewert. Falls während des Zugriffs auf die Daten keine Modifikation der Daten stattgefunden hat, gibt die Funktion »0« zurück, ansonsten einen Wert ungleich »0«.

read_seqretry_irqrestore

#include <linux/seqlock.h>

int read_seqretry_irqrestore(seqlock_t *sl, unsigned iv, unsigned int iflags);

Die Funktion dient dazu festzustellen, ob parallel zum Zugriff auf die durch »sl« geschützten Daten eine andere Instanz die Daten verändert hat. Ist das der Fall, muss der Zugriff wiederholt werden. »iv« enthält den per read_seqbegin aufgenommenen Zählerwert. Außerdem werden die Interrupt-Flags gemäß »iflags« restauriert.

Rückgabewert. Falls während des Zugriffs auf die Daten keine Modifikation der Daten stattgefunden hat, gibt die Funktion »0« zurück, ansonsten einen Wert ungleich »0«.

read_unlock

#include <linux/spinlock.h>

void read_unlock(rwlock_t *lock);

Das Makro gibt das zuvor mit read_lock zum Lesen reservierte Lese-/Schreib-Spinlock »lock« frei.

read_unlock_bh

#include <linux/spinlock.h>

void read_unlock_bh(rwlock_t *lock);

Das Makro gibt das zuvor mit read_lock_bh zum Lesen reservierte Lese-/Schreib-Spinlock »lock« frei. Softirqs sind nach Aufruf der Funktion ebenfalls wieder zugelassen.

read_unlock_irq

#include <linux/spinlock.h>

void read_unlock_irq(rwlock_t *lock);

Das Makro gibt das zuvor mit read_lock_irq zum Lesen reservierte Lese-/Schreib-Spinlock »lock« frei. Nach Aufruf der Funktion sind Interrupts zugelassen.

read_unlock_irqrestore

#include <linux/spinlock.h>

void read_unlock_irqrestore(rwlock_t *lock, unsigned long iflags);

Das Makro gibt das zuvor mit read_lock_irqsave zum Lesen reservierte Lese-/Schreib-Spinlock »lock« frei. Die Interrupt-Flags werden gemäß »iflags« restauriert.

read[bwl]

#include <asm/io.h>

volatile u8 readb(void *addr);

volatile u16 readw(void *addr);

volatile u32 readl(void *addr);

Über diese Makros wird von der Adresse »addr« ein 8-, 16- oder 32-Bit-Wort eingelesen.

Rückgabewert. Die Funktionen geben den Wert an der gelesenen Speicher-Adresse zurück.

register_blkdev

#include <linux/fs.h>

int register_blkdev(unsigned int major_nr, const char *driver_name);

Diese Funktion wird vom Treiber in der Funktion init_module aufgerufen. Sie meldet den Treiber beim Betriebssystem mit der Major-Nummer »major_nr« als Block-Device-Treiber an. Der Treiber wird hierbei unter dem Namen »driver_name« geführt.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück. Ist entweder die Major-Nummer außerhalb des gültigen Bereiches oder der Gerätename »DeviceName« falsch, gibt die Funktion »-EFAULT« zurück.

register_chrdev

#include <linux/fs.h>

int register_chrdev(unsigned int major_nr, const char *driver_name, struct file_operations *fops);

Die Funktion meldet den Treiber beim Betriebssystem unter der Majornumber »major_nr« an. Wird anstelle einer definierten Major-Nummer »0« übergeben, teilt das IO-Subsystem des Kernels dem Treiber dynamisch eine Major-Nummer zu. Der Parameter »driver_name« spezifiziert den Namen, unter dem der Treiber beim System angemeldet ist. Dieser Name taucht beispielsweise unter der Datei /proc/devices wieder auf und wird bei der dynamischen Zuteilung der Major-Nummer dazu benötigt, um den Gerätedateieintrag im Filesystem durchzuführen.

Die Funktion register_chrdev wird vom Treiber in init_module aufgerufen. Sie übergibt dem Betriebssystem die im Treiber definierte Struktur »struct file_operations« (Funktionstabelle).

Rückgabewert. Wurde die Anmeldung des Treibers vom Betriebssystem akzeptiert, gibt dieser eine positive Zahl zurück. »0« bedeutet dabei »ok«, eine Zahl größer »0« entspricht einer dynamisch zugeteilten Major-Nummer.

Im Fehlerfall gibt die Funktion einen negativen Wert zurück.

register_chrdev_region

#include <linux/fs.h>

int register_chrdev_region(dev_t from, unsigned count, char *name);

Die Funktion reserviert für den Treiber Gerätenummern. »from« spezifiziert die erste zu reservierende Gerätenummer und »count« die Anzahl der zu reservierenden Gerätenummern. Die Reservierung selbst wird im Kernel unter dem Namen »name« geführt.

Rückgabewert. Bei Erfolg gibt die Funktion »0« zurück, ansonsten einen Fehlercode.

register_netdev

#include <linux/netdevice.h>

int register_netdev(struct net_device *dev);

Die Funktion registriert den durch die Struktur »dev« gegebenen Netzwerktreiber beim Betriebssystem. Die Struktur »dev« wird zuvor über die Funktion alloc_netdev alloziert und initialisiert. Im Vergleich zu der ebenfalls nutzbaren Funktion register_netdevice sorgt register_netdev für das notwendige Locking.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0«, ansonsten einen Fehlercode zurück.

release_region

#include <linux/ioport.h>

void release_region(unsigned long from, unsigned long length);

Die Funktion gibt den durch »from« und »length« zuvor allozierten IO-Bereich wieder frei. Sie wird in Zukunft wohl durch die Funktion release_resource abgelöst werden.

release_mem_region

#include <linux/ioport.h>

void release_mem_region(unsigned long from, unsigned long length);

Die Funktion gibt den durch »from« und »length« gekennzeichneten Speicherbereich frei.

remove_proc_entry

#include <linux/proc_fs.h>

void remove_proc_entry(const char *name, struct proc_dir_entry *parent);

Ein Eintrag im Proc-Filesystem wird über diese Funktion wieder entfernt. Der zu entfernende Eintrag wird durch das Argument »name« spezifiziert. Der Parameter »parent« gibt das Verzeichnis an, in dem der zu entfernende Eintrag steht. Die Funktion remove_proc_entry wird vornehmlich in cleanup_module aufgerufen.

request_dma

#include <asm/dma.h>

int request_dma(unsigned int dmanr, const char *device_id);

Über diese Funktion wird der DMA-Kanal »dmanr« unter dem Namen »device_id« reserviert.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0« zurück, ansonsten einen Fehlercode (z.B »-EBUSY«).

request_irq

#include <linux/interrupt.h>

int request_irq(unsigned int irq, irqreturn_t (*handler)(int,void*,struct pt_regs*) , unsigned long flags, const char *devname, void *dev_id);

Über diese Funktion wird beim Betriebssystem der Interrupt »irq« angefordert. Wird der Interrupt durch die Hardware ausgelöst, wird die Funktion »handler« aufgerufen. Das Verhalten kann über die »flags« eingestellt werden. Folgende Werte stehen hier zur Verfügung:

SA_SHIRQ Der Interrupt kann von mehreren Treibern verwendet werden.
SA_INTERRUPT Lokale Interrupts bleiben während der Abarbeitung der ISR gesperrt (wird normalerweise gesetzt).
SA_SAMPLE_RANDOM Der Interrupt tritt mehr oder minder zufällig auf und kann damit genutzt werden, um die Entropie zur Generierung von Zufallszahlen zu erhöhen.

Der Interrupt wird unter dem Namen »devname« angemeldet (sichtbar in /proc/interrupts). Der Parameter »dev_id« muss einen eindeutigen Wert haben, »NULL« darf nicht übergeben werden. Meist wird hier die eindeutige Adresse einer Datenstruktur (z.B. vom Typ struct cdev) verwendet. Der Wert von »dev_id« muss innerhalb des Treibers bekannt sein, da er zum Abmelden (siehe free_irq) wiederum benötigt wird.

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0« zurück, ansonsten einen Fehlercode (z.B »-EBUSY«).

request_mem_region

#include <linux/ioport.h>

struct resource *request_mem_region(unsigned long from, unsigned long length, const char *name);

Die Funktion reserviert einen Speicherbereich der Länge »length« ab der Adresse »from« unter dem Namen »name«.

Rückgabewert. Konnte der Speicherbereich alloziert werden, wird die Adresse der neuen Ressource zurückgegeben, ansonsten »NULL«.

request_module

#include <linux/module.h>

int request_module(const char *fmt, ...);

Die Funktion versucht das durch »fmt« und »...« spezifizierte Modul zu laden.

Rückgabewert. Die Funktion gibt »0« zurück, falls das Modul geladen werden konnte, ansonsten einen negativen Fehlercode. Die Funktion garantiert aber nicht, dass die angeforderte Funktionalität auch zur Verfügung steht; dass sich beispielsweise das Modul selbst mit einem Fehlercode wieder entladen hat.

request_region

#include <linux/ioport.h>

struct resource *request_region(unsigned long from, unsigned long length, const char *name);

Die Funktion reserviert einen IO-Bereich der Länge »length« ab der Adresse »from« unter dem Namen »name«.

Rückgabewert. Konnte der IO-Bereich alloziert werden, wird die Adresse der neuen Ressource zurückgegeben, ansonsten »NULL«.

rmb

#include <asm/system.h>

void rmb(void);

Read Barrier: Vor dem nächsten Leseauftrag werden sämtliche bisher angestoßenen Leseaufträge durchgeführt.

Siehe auch: mb, wmb und barrier.

rq_data_dir

#include <linux/blkdev.h>

int rq_data_dir(struct request *r);

Der Zugriff auf die Transferrichtung des Requests »r« erfolgt über dieses Makro.

Rückgabewert. Das Makro gibt READ oder WRITE zurück. Beide Konstanten sind in <linux/fs.h> deklariert.

rq_for_each_bio

#include <linux/blkdev.h>

rq_for_each_bio(struct bio *bio, struct request *req);

Das Makro bildet eine Schleife, innerhalb der die einzelnen BIO-Strukturen des Requests »req« extrahiert werden. Die BIO-Strukturen werden in die Variable »bio« abgelegt.

rwlock_init

#include <linux/spinlock.h>

void rwlock_init(rwlock_t *rwlock);

Das Makro initialisiert das Lese-/Schreib-Spinlock »rwlock«.

schedule

#include <linux/sched.h>

void schedule(void);

Diese Funktion ruft explizit den Scheduler auf. Die Funktion ist nützlich, um auf einfache und elegante Weise eine Task schlafen legen zu können.

    current->timeout = j;
    current->state = TASK_INTERRUPTIBLE;
    schedule();
    current->timeout = 0;

schedule_timeout

#include <linux/sched.h>

long schedule_timeout(long timeout);

Die Funktion legt den aktiven Rechenprozess (Treiberinstanz, Kernel-Thread) für »timeout«-Jiffies schlafen. »Timeout« wird als Relativzeit angegeben. Zuvor muss jedoch der Task-Zustand mit Hilfe der Funktion set_current_state auf »TASK_UNINTERRUPTIBLE« oder auf »TASK_INTERRUPTIBLE« gesetzt werden. Im ersten Fall wird der zugehörige Prozess nur dann wieder aufgeweckt, wenn die Wartezeit abgelaufen ist. Im zweiten Fall kann der Prozess auch durch Schicken eines Signals wieder aktiviert werden.

Rückgabewert. Die Funktion gibt »0« zurück oder – falls die Funktion durch ein Signal unterbrochen wurde – die übrig gebliebene Wartezeit.

schedule_delayed_work

#include <linux/workqueue.h>

int schedule_delayed_work(struct work_struct *work, unsigned long delay);

Die Funktion übergibt »work« der Event-Workqueue, die die in »work« definierte Funktion (»work->func») in »delay«-Jiffies aufruft.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_work, queue_delayed_work, schedule_work und flush_scheduled_work.

Rückgabewert. Ein Rückgabewert von »0« zeigt einen Fehler an. Ein Wert ungleich »0« bedeutet, dass »work« erfolgreich der Event-Workqueue zur Abarbeitung übergeben wurde.

schedule_work

#include <linux/workqueue.h>

int schedule_work(struct work_struct *work);

Die Funktion übergibt »work« der Event-Workqueue, die die in »work« definierte Funktion (»work->func») aufruft.

Siehe auch: create_workqueue, flush_workqueue, destroy_workqueue, INIT_WORK, DECLARE_WORK, queue_work, queue_delayed_work, schedule_delayed_work und flush_scheduled_work.

Rückgabewert. Ein Rückgabewert von »0« zeigt einen Fehler an. Ein Wert ungleich »0« bedeutet, dass »work« erfolgreich der Event-Workqueue zur Abarbeitung übergeben wurde.

scnprintf

#include <linux/kernel.h>

int scnprintf(char *buf, size_t size, const char *fmt, ...);

Die erst ab Kernel 2.6.4 verfügbare Funktion formatiert einen String gemäß »fmt« und den Parametern »...«. Das Ergebnis wird mit einer maximalen Länge von »size« Bytes in den Buffer »buf« abgelegt.

Siehe auch: sprintf, strcat, strncat, strncpy, strlcpy, simple_strtoul, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt die Länge des abgelegten Strings ohne die abschließende »'\0'« zurück. Ist »size« gleich »0« gibt die Funktion »0« zurück.

sema_init

#include <asm/semaphore.h>

void sema_init(struct semaphore *sema, int val);

Über diese Inline-Funktion wird ein Semaphor initialisiert. Der Parameter »val« gibt an, wie viele Prozesse zu einem Zeitpunkt einen kritischen Abschnitt betreten dürfen. Soll das Semaphor als Mutex verwendet werden, hat »val« den Wert »1«. In diesem Fall kann aber auch das Makro DECLARE_MUTEX verwendet werden, welches sowohl die Definition des Semaphors (Anlegen von Speicherplatz) als auch die Initialisierung durchführt.

Siehe auch: up, down, down_interruptible und down_trylock.

seq_open

#include <linux/seq_file.h>

int seq_open(struct file *file, struct seq_operations *op);

Die Funktion verknüpft die Funktionstabelle »op« mit der Sequenz-Datei »file« (Initialisierung).

Rückgabewert. Die Funktion gibt im fehlerfreien Fall »0« zurück, ansonsten einen negativen Wert.

seq_printf

#include <linux/seq_file.h>

int seq_printf(struct seq_file *m, const char *f, ...);

Die Funktion dient zur Ausgabe der Daten in die Sequenz-Datei »m«. Die Funktion wird wie printf respektive fprintf verwendet, so dass »f« der bekannte Formatstring ist.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten »-1« zurück.

seq_putc

#include <linux/seq_file.h>

int seq_putc(struct seq_file *m, charc);

Die Inline-Funktion gibt das Zeichen »c« in die Sequenz-Datei »m« aus.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten »-1« zurück.

seq_puts

#include <linux/seq_file.h>

int seq_puts(struct seq_file *m, const char *s);

Die Inline-Funktion gibt den String »s« in die Sequenz-Datei »m« aus.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten »-1« zurück.

set_bit

#include <asm/bitops.h>

void set_bit(int nr, volatile unsigned long *addr);

Die Funktion setzt das Bit Nummer »nr« an der Speicheradresse »addr«. Der Zugriff auf das Bit über diese Funktion ist unteilbar. Solange die Funktion aktiv ist, kann keine andere Funktion auf die Speicherzelle »addr« zugreifen. Das niederwertigste Bit hat die Nummer »0«.

Siehe auch: test_bit, test_and_change_bit, test_and_clear_bit, test_and_set_bit, change_bit und clear_bit.

set_capacity

#include <linux/genhd.h>

void set_capacity(struct gendisk *disk, sector_t size);

Über diese Inline-Funktion wird mit »size« die Kapazität – die Größe – eines Blockgerätes in Sektoren festgelegt. Jeder Sektor umfasst fix die Größe von 512 Bytes.

set_current_state

#include <linux/sched.h>

void set_current_state(int state_value);

Das Makro setzt den Task-Zustand der aktuellen Task (»current«) auf den Wert »state_value«.

signal_pending

#include <linux/sched.h>

int signal_pending(struct task_struct *p);

Mit dieser Funktion kann festgestellt werden, ob dem durch »p« repräsentierten Thread (Treiberinstanz oder Kernel-Thread) ein Signal geschickt wurde oder nicht.

    if( !signal_pending(current) ) {
        ... // ein Signal liegt vor 
    } else {
        ... // kein Signal
    }

Rückgabewert. Die Funktion gibt »0« zurück, falls ein Signal vorliegt, ansonsten einen Wert ungleich »0«.

simple_strtoul

#include <linux/kernel.h>

unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base);

long simple_strtol(const char *cp, char **endp, unsigned int base);

Die Funktion konvertiert den String »cp» in einen »unsigned long«- respektive »long«-Wert. »base« spezifiziert die Basis, mit der konvertiert wird. Ist »base« »0« wird die Basis automatisch bestimmt (beginnt der String mit »0x«, findet die Konvertierung zur Basis 16 statt, beginnt der String mit »0«, wird als Basis 8 genommen und ansonsten die Basis 10). Ist »endp« nicht »NULL«, wird der Zeiger auf das Ende des dekodierten Strings gesetzt.

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncat, strncpy, strlcpy, strlen und strncmp.

Rückgabewert. Die Funktion gibt den konvertierten Wert zurück.

single_open

#include <linux/seq_file.h>

int single_open(struct file *file, int (*show)(struct seq_file *, void *), void *data);

Durch Aufruf dieser Funktion wird dem Single-File die Funktion »show« bekannt gegeben, die die Aufbereitung der Daten vornimmt (Show-Funktion). Diese Funktion wird mit »file« verknüpft. Außerdem kann ein zusätzlicher Parameter »data« angegeben werden. Dieser wird später der Funktion »show« wieder übergeben.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0«, ansonsten einen negativen Wert zurück. Falls die Reservierung von Speicher innerhalb der Funktion fehlschlägt, ist dies »-ENOMEM«.

single_release

#include <linux/seq_file.h>

int single_release(struct inode *inode, struct file *file);

Die Funktion gibt die Datenstrukturen wieder frei, die mit der Sequenz-Datei »file« verknüpft sind. Die Funktion selbst wird normalerweise direkt in die struct file_operations im Element .release eingetragen.

Rückgabewert. Die Funktion gibt »0« zurück.

skb_put

#include <linux/skbuff.h>

unsigned char *skb_put(struct sk_buff *skb, unsigned int len);

Die Funktion erweitert den verwendeten Datenbereich des Socket Buffers »skb« (im Rahmen der bei alloc_skb angegebenen Größe) um »len« Bytes (Anpassung der Zeiger in der Datenstruktur struct sk_buff). Wird der Buffer über die eigentliche Größe hinaus verwendet, kommt es zu einem Kernel-Panic.

Rückgabewert. Die Funktion gibt einen Zeiger auf das erste Byte des hinzugefügten Speicherbereiches zurück.

snprintf

#include <linux/kernel.h>

int snprintf(char *buf, size_t size, const char *fmt, ...);

Die Funktion formatiert einen String gemäß »fmt« und den Parametern »...«. Das Ergebnis wird mit einer maximalen Länge von »size« Bytes in den Buffer »buf« abgelegt.

Siehe auch: sprintf, scnprintf, strcat, strncat, strncpy, strlcpy, simple_strtoul, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt nicht wie sprintf die Länge des abgelegten Strings (ohne abschließende »0«) zurück, sondern die Gesamtlänge des Strings, die ausgegeben werden sollte (unabhängig von »size«). Soll das Ergebnis für weitere Berechnungen verwendet werden, muss überprüft werden, ob die Anzahl der Zeichen, die ausgegeben würden (Returnwert) größer ist als die Anzahl der Zeichen, die maximal ausgegeben werden konnten (»size«).

spin_lock

#include <linux/spinlock.h>

void spin_lock(spinlock_t *lock);

Diese Funktion wird vor Betreten des durch »lock« geschützten, kritischen Abschnittes aufgerufen. Falls das Spinlock belegt ist, wird so lange (aktiv) gewartet, bis das Spinlock wieder freigegeben ist. Da die Funktion durch Interrupts und Softirqs unterbrochen werden kann, darf sie nur verwendet werden, um einen kritischen Abschnitt, der zwischen Treiberinstanzen und Kernel-Threads existiert, zu schützen. Zur Freigabe muss die Funktion spin_unlock aufgerufen werden.

Siehe auch: spin_lock_init, spin_unlock, spin_lock_bh, spin_unlock_bh, spin_lock_irq, spin_unlock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_lock_bh

#include <linux/spinlock.h>

void spin_lock_bh(spinlock_t *lock);

Diese Funktion wird vor Betreten des durch »lock« geschützten, kritischen Abschnittes aufgerufen. Falls das Spinlock belegt ist, wird so lange (aktiv) gewartet, bis das Spinlock wieder freigegeben ist. Die Funktion sperrt zusätzlich die Abarbeitung von Softirqs, sie kann allerdings weiterhin durch Hardware-Interrupts unterbrochen werden. Sie darf verwendet werden, um damit einen kritischen Abschnitt zu schützen, der zwischen Treiberinstanzen, Kernel-Threads und Softirqs besteht. Zur Freigabe muss die Funktion spin_unlock_bh aufgerufen werden.

Siehe auch: spin_lock_init, spin_lock, spin_unlock, spin_unlock_bh, spin_lock_irq, spin_unlock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_lock_init

#include <linux/spinlock.h>

void spin_lock_init(spinlock_t *splock);

Das Makro initialisiert das Spinlock »splock«.

Siehe auch: spin_lock, spin_unlock, spin_lock_bh, spin_unlock_bh, spin_lock_irq, spin_unlock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_lock_irq

#include <linux/spinlock.h>

void spin_lock_irq(spinlock_t *lock);

Das Makro wird vor Betreten des durch »lock« geschützten, kritischen Abschnittes aufgerufen. Falls das Spinlock belegt ist, wird so lange (aktiv) gewartet, bis das Spinlock wieder freigegeben ist. Das Makro sperrt die Abarbeitung von Interrupts, auch Softirqs. Die Interrupt-Flags werden nicht gesichert. Zur Freigabe muss die Funktion spin_unlock_irq aufgerufen werden.

Siehe auch: spin_lock_init, spin_lock, spin_unlock, spin_lock_bh, spin_unlock_bh, spin_unlock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_lock_irqsave

#include <linux/spinlock.h>

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);

Das Makro wird vor Betreten des durch »lock« geschützten, kritischen Abschnittes aufgerufen. Falls das Spinlock belegt ist, wird so lange (aktiv) gewartet, bis das Spinlock wieder freigegeben ist. Die Funktion speichert den Inhalt des Flag-Registers »iflags« und sperrt die Abarbeitung von Interrupts, auch Softirqs. Zur Freigabe muss die Funktion spin_unlock_irqrestore aufgerufen werden.

Siehe auch: spin_lock_init, spin_lock, spin_unlock, spin_lock_bh, spin_unlock_bh, spin_lock_irq, spin_unlock_irq und spin_unlock_irqrestore.

spin_unlock

#include <linux/spinlock.h>

void spin_unlock(spinlock_t *lock);

Die Funktion wird zur Freigabe des zuvor per spin_lock reservierten Spinlocks »lock« aufgerufen.

Siehe auch: spin_lock_init, spin_lock, spin_lock_bh, spin_unlock_bh, spin_lock_irq, spin_unlock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_unlock_bh

#include <linux/spinlock.h>

void spin_unlock_bh(spinlock_t *lock);

Die Funktion wird zur Freigabe des zuvor per spin_lock_bh reservierten Spinlocks »lock« aufgerufen.

Siehe auch: spin_lock_init, spin_lock, spin_unlock, spin_lock_bh, spin_lock_irq, spin_unlock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_unlock_irq

#include <linux/spinlock.h>

void spin_unlock_irq(spinlock_t *lock);

Die Funktion wird zur Freigabe des zuvor per spin_lock_irq reservierten Spinlocks »lock« aufgerufen.

Siehe auch: spin_lock_init, spin_lock, spin_unlock, spin_lock_bh, spin_unlock_bh, spin_lock_irq, spin_lock_irqsave und spin_unlock_irqrestore.

spin_unlock_irqrestore

#include <linux/spinlock.h>

void spin_unlock_irqrestore(spinlock_t lock, unsigned long iflags);

Die Funktion wird zur Freigabe des zuvor per spin_lock_irqsave reservierten Spinlocks »lock« aufgerufen. Außerdem wird das Flag-Register mit dem Wert »iflags« restauriert.

Siehe auch: spin_lock_init, spin_lock, spin_unlock, spin_lock_bh, spin_unlock_bh, spin_lock_irq, spin_unlock_irq und spin_lock_irqsave.

sprintf

#include <linux/kernel.h>

int sprintf(char *buf, const char *fmt, ...);

Die Funktion formatiert einen String gemäß »fmt« und den Parametern »...« Das Ergebnis wird in den Buffer »buf« abgelegt. Die Funktion entspricht der aus dem Applikationsbereich stammenden Funktion sprintf.

Diese Funktion ist unsicher, da ein Überschreiben des Buffers »buf« möglich ist. Daher sollte sie nach Möglichkeit zu Gunsten der Funktion snprintf nicht verwendet werden.

Siehe auch: scnprintf, snprintf, strcat, strncat, strncpy, strlcpy, simple_strtoul, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt die Länge des in »buf« abgelegten Strings (ohne abschließende »0«) zurück.

strcat

#include <linux/string.h>

char *strcat(char *dest, const char *src);

Die Funktion hängt den (null-terminierten) String »src« an den (null-terminierten) String »dest« an. Der Aufrufer hat sicherzustellen, dass »dest« groß genug ist, um »src« aufzunehmen. Die Funktion ähnelt der aus dem Applikationsbereich bekannten Funktion strcat.

Da mit dieser Funktion ein Überschreiben von »dest« möglich ist, sollte die Funktion nicht verwendet werden. Stattdessen ist strncat vorzuziehen.

Siehe auch: sprintf, scnprintf, snprintf, strncat, strncpy, strlcpy, simple_strtoul, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Ergebnisstring (also auf »dest«) zurück.

strlcpy

#include <linux/string.h>

size_t strlcpy(char *dest, char *src, size_t count);

Die Funktion kopiert maximal »count« Zeichen des null-terminierten Strings »src« nach »dest«. Die beiden Strings dürfen nicht überlappen. Außerdem muss der Speicherplatz von »dest« groß genug sein, um »src« aufzunehmen. Im Gegensatz zu strncpy stellt die Funktion sicher, dass der Ergebnisstring null-terminiert ist.

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncat, strncpy, simple_strtoul, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt die Stringlänge von »len« zurück.

strlen

#include <linux/string.h>

size_t strlen(const char *s);

Die Funktion berechnet die Länge des Strings »s«.

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncat, strncpy, simple_strtoul, strlcpy, strncmp und strstr.

Rückgabewert. Die Funktion gibt die Länge des Strings »s« zurück.

strncat

#include <linux/string.h>

char *strncat(char *dest, const char *src, size_t maxlength);

Die Funktion hängt den (null-terminierten) String »src« mit maximal »maxlength« Zeichen an den (null-terminierten) String »dest« an. Der Aufrufer hat sicherzustellen, dass »dest« groß genug ist, um »src« aufzunehmen. Die Funktion ähnelt der aus dem Applikationsbereich bekannten Funktion strncat.

Im Gegensatz zu strncpy stellt die Funktion sicher, dass der Ergebnisstring null-terminiert ist.

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncpy, strlcpy, simple_strtoul, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Ergebnisstring (also auf »dest«) zurück.

strncmp

#include <linux/string.h>

int strncmp(const char *cs, const char *ct, size_t count);

Die Funktion vergleicht die ersten »count« Zeichen der beiden Strings »cs« und »ct« miteinander.

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncat, strncpy, simple_strtoul, strlcpy, strlen und strstr.

Rückgabewert. Die Funktion gibt bei Gleichheit »0« zurück. Ist »cs« kleiner als »ct«, gibt die Funktion einen negativen Wert zurück; ist »cs« größer, einen positiven Wert.

strncpy

#include <linux/string.h>

char *strncpy(char *dest, char *src, size_t count);

Die Funktion kopiert maximal »count« Zeichen des null-terminierten Strings »src« nach »dest«. Die beiden Strings dürfen nicht überlappen. Außerdem muss der Speicherplatz von »dest« groß genug sein, um »src« aufzunehmen.

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncat, strlcpy, strlen, strncmp und strstr.

Rückgabewert. Die Funktion gibt einen Zeiger auf den Ergebnisstring (also auf »dest«) zurück, der unter Umständen nicht null-terminiert ist.

strstr

#include <linux/string.h>

char *strstr(const char *s1, const char *s2);

Die Funktion sucht den String »s2» im String »s1».

Siehe auch: sprintf, scnprintf, snprintf, strcat, strncat, strncpy, simple_strtoul, strlcpy, strlen und strncmp.

Rückgabewert. Die Funktion gibt »NULL« zurück, falls »s2« nicht in »s1« gefunden wurde, ansonsten die Startadresse des Strings »s2« in »s1«.

symbol_get

#include <linux/modul.h>

symbol_get(symbol);

Normalerweise kann ein Modul nur auf die externen Variablen oder Funktionen zugreifen, die bereits Teil des Kernels sind, die also entweder fest in den Kernel einkompiliert wurden oder bereits als Modul geladen worden sind. Falls allerdings auf ein Symbol zugegriffen werden soll, welches erst zu einem späteren Zeitpunkt in den Kernel geladen wird, muss das Makro symbol_get verwendet werden.

Der Kernel verhindert das Entladen des Moduls, welches das angeforderte Symbol zur Verfügung stellt, solange eine andere Komponente darauf zugreift. Daher muss das Modul die Funktion symbol_put oder symbol_put_addr aufrufen, wenn das Symbol nicht mehr gebraucht wird.

Die Funktion darf im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Die Funktion gibt die Adresse des Symbols »symbol« zurück oder – falls das Symbol im Kernel nicht bekannt ist – »NULL«.

symbol_put

#include <linux/wait.h>

void symbol_put(symbol);

Die Funktion gibt das zuvor mit symbol_get angeforderte Symbol »symbol« frei.

symbol_put_addr

#include <linux/wait.h>

void symbol_put_addr(addr);

Die Funktion gibt das zur Adresse »addr« gehörige Symbol, welches zuvor mit symbol_get angefordert wurde, frei.

tasklet_disable

#include <linux/interrupt.h>

void tasklet_disable(struct tasklet_struct *t);

Die Inline-Funktion disabled (deaktiviert) das Tasklet »t«. Ist das Tasklet gescheduled, wird es so lange nicht abgearbeitet, bis es wieder aktiviert (enabled) wird.

Siehe auch: DECLARE_TASKLET, DECLARE_TASKLET_DISABLED, tasklet_init, tasklet_kill, tasklet_schedule, tasklet_hi_schedule und tasklet_enable.

tasklet_enable

#include <linux/interrupt.h>

void tasklet_enable(struct tasklet_struct *t);

Die Inline-Funktion aktiviert (enabled) das Tasklet »t«. Ist das Tasklet gescheduled, wird es abgearbeitet.

Siehe auch: DECLARE_TASKLET, DECLARE_TASKLET_DISABLED, tasklet_init, tasklet_kill, tasklet_schedule, tasklet_hi_schedule und tasklet_disable.

tasklet_hi_schedule

#include <linux/interrupt.h>

void tasklet_hi_schedule(struct tasklet_struct *t);

Die Funktion übergibt das in »t« spezifizierte Tasklet zur Abarbeitung an den Kernel. Die mit dieser Funktion übergebenen Tasklets werden abgearbeitet, sobald keine ISR mehr abzuarbeiten ist.

Siehe auch: DECLARE_TASKLET, DECLARE_TASKLET_DISABLED, tasklet_init, tasklet_kill, tasklet_schedule, tasklet_disable und tasklet_enable.

tasklet_init

#include <linux/interrupt.h>

void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long), unsigned long data);

Die Funktion initialisiert das Tasklet »t«. »Func» repräsentiert die Funktion, die bei Abarbeitung des Tasklets mit »data« als Parameter aufgerufen wird.

Siehe auch: DECLARE_TASKLET, DECLARE_TASKLET_DISABLED, tasklet_kill, tasklet_schedule, tasklet_hi_schedule, tasklet_disable und tasklet_enable.

tasklet_kill

#include <linux/interrupt.h>

void tasklet_kill(struct tasklet_struct *t);

Die Funktion ist gedacht, um das Tasklet »t« wieder zu entfernen.

Siehe auch: DECLARE_TASKLET, DECLARE_TASKLET_DISABLED, tasklet_init, tasklet_schedule, tasklet_hi_schedule, tasklet_disable und tasklet_enable.

tasklet_schedule

#include <linux/interrupt.h>

void tasklet_schedule(struct tasklet_struct *t);

Die Funktion übergibt das in »t« spezifizierte Tasklet zur Abarbeitung an den Kernel. Die mit dieser Funktion übergebenen Tasklets werden abgearbeitet, sobald keine ISR und keine übrigen Tasklets mehr abzuarbeiten sind.

Siehe auch: DECLARE_TASKLET, DECLARE_TASKLET_DISABLED, tasklet_init, tasklet_kill, tasklet_hi_schedule, tasklet_disable und tasklet_enable.

test_and_change_bit

#include <asm/bitops.h>

int test_and_change_bit(int nr, volatile unsigned long *addr);

Die Inline-Funktion ändert (toggelt) das Bit »nr« von »addr« und gibt den Zustand des Bits vor dem Setzen zurück.

Siehe auch: test_bit, test_and_clear_bit, test_and_set_bit, change_bit, clear_bit und set_bit.

Rückgabewert. War das Bit Nummer »nr« vor Aufruf der Funktion »0«, gibt die Funktion »0« zurück; ansonsten »nicht 0«.

test_and_clear_bit

#include <asm/bitops.h>

int test_and_clear_bit(int nr, volatile unsigned long *addr);

Die Inline-Funktion löscht das Bit »nr« von »addr« und gibt den Zustand des Bits vor dem Setzen zurück.

Siehe auch: test_bit, test_and_change_bit, test_and_set_bit, change_bit, clear_bit und set_bit.

Rückgabewert. War das Bit Nummer »nr« vor Aufruf der Funktion »0«, gibt die Funktion »0« zurück; ansonsten »nicht 0«.

test_and_set_bit

#include <asm/bitops.h>

int test_and_set_bit(int nr, volatile unsigned long *addr);

Die Inline-Funktion setzt das Bit »nr« von »addr« und gibt den Zustand des Bits vor dem Setzen zurück.

Siehe auch: test_bit, test_and_change_bit, test_and_clear_bit, change_bit, clear_bit und set_bit.

Rückgabewert. War das Bit Nummer »nr« vor Aufruf der Funktion »0«, gibt die Funktion »0« zurück; ansonsten »nicht 0«.

test_bit

#include <asm/bitops.h>

int test_bit(int nr, volatile unsigned long *addr);

Das Makro testet Bit »nr« der Variablen »addr«.

Siehe auch: test_and_change_bit, test_and_clear_bit, test_and_set_bit, change_bit, clear_bit und set_bit.

Rückgabewert. War das Bit Nummer »nr« vor Aufruf der Funktion »0«, gibt die Funktion »0« zurück; ansonsten »nicht 0«.

time_after

#include <linux/jiffies.h>

int time_after(unsigned long a, unsigned long b);

Das Makro vergleicht die beiden Zeitpunkte »a« und »b«. Die Zeitpunkte »a« und »b« sind in Jiffies angegeben.

Rückgabewert. Falls »a« einen späteren Zeitpunkt als »b« kennzeichnet, ergibt das Makro »1«, ansonsten »0«.

time_after_eq

#include <linux/jiffies.h>

int time_after_eq(unsigned long a, unsigned long b);

Das Makro vergleicht die beiden Zeitpunkte »a« und »b«. Die Zeitpunkte »a« und »b« sind in Jiffies angegeben.

Rückgabewert. Falls »a« einen späteren oder den gleichen Zeitpunkt wie »b« kennzeichnet, ergibt das Makro »1«, ansonsten »0«.

time_before

#include <linux/jiffies.h>

int time_before(unsigned long a, unsigned long b);

Das Makro vergleicht die beiden Zeitpunkte »a« und »b«. Die Zeitpunkte »a« und »b« sind in Jiffies angegeben.

Rückgabewert. Das Makro ergibt »1«, falls der Zeitpunkt »a« vor dem Zeitpunkt »b« liegt.

time_before_eq

#include <linux/jiffies.h>

int time_before_eq(unsigned long a, unsigned long b);

Das Makro vergleicht die beiden Zeitpunkte »a« und »b«. Die Zeitpunkte »a« und »b« sind in Jiffies angegeben.

Rückgabewert. Das Makro ergibt »1«, falls der Zeitpunkt »a« vor dem Zeitpunkt »b« liegt oder mit diesem identisch ist.

timer_pending

#include <linux/timer.h>

int timer_pending(struct timer_list *timer);

Die Inline-Funktion überprüft, ob der Timer »timer« aktiv (zur Abarbeitung dem Kernel übergeben) oder deaktiv ist.

Rückgabewert. Die Funktion gibt im Falle eines aktiven Timers »1«, ansonsten »0« zurück.

timespec_to_jiffies

#include <linux/time.h>

unsigned long timespec_to_jiffies(struct timespec *value);

Die Inline-Funktion konvertiert die übergebene Zeitinformation »value«, gegeben in Sekunden und Nanosekunden in Jiffies. Die struct timespec ist in der Header-Datei <linux/time.h> deklariert:

struct timespec {
    time_t tv_sec;  /* seconds (long) */
    long   tv_nsec; /* nanoseconds */
};

Rückgabewert. Die Funktion gibt den Zeitwert in Jiffies zurück.

timeval_to_jiffies

#include <linux/time.h>

unsigned long timeval_to_jiffies(struct timeval *value);

Die Inline-Funktion konvertiert die übergebene Zeitinformation »value« in Sekunden und μ-sekunden in Jiffies. Die struct timeval ist in der Header-Datei <linux/time.h> deklariert:

struct timeval {
    time_t      tv_sec;  /* seconds (long) */
    suseconds_t tv_usec; /* microseconds (long) */
};

Rückgabewert. Die Funktion gibt den Zeitwert in Jiffies zurück.

toupper

#include <linux/ctype.h>

unsigned char toupper(unsigned char c);

unsigned char tolower(unsigned char c);

unsigned char toascii(unsigned char c);

toascii

Das Makro konvertiert »c« in ein ASCII-Zeichen (7-Bit unsigned char).

tolower

Die Inline-Funktion konvertiert – soweit möglich – »c« in einen Kleinbuchstaben.

toupper

Die Inline-Funktion konvertiert – soweit möglich – »c« in einen Großbuchstaben.

Rückgabewert. Die Funktionen geben den Wert des konvertierten Zeichens zurück.

try_module_get

#include <linux/module.h>

int try_module_get(struct module *module);

Die Inline-Funktion inkrementiert den Referenzzähler des Moduls »module«. Solange der Referenzzähler größer als »0« ist, kann das Modul nicht entladen werden. Normalerweise wird der Referenzzähler des Moduls automatisch durch den Kernel erhöht.

Siehe auch: module_put und request_module.

Rückgabewert. Die Funktion gibt »1« zurück, falls der Referenzzähler erhöht werden konnte, und »0«, falls das Modul nicht mehr geladen war.

udelay

#include <asm/delay.h>

void udelay(unsigned long MikroSeconds);

Diese Funktion verzögert den Ablauf des Prozesses bzw. des Treibers um die im Feld »MikroSeconds« angegebenen μ-Sekunden. Die Verzögerung wird durch aktives Warten (Busy-Loop) erreicht und sollte

  1. möglichst vermieden werden und

  2. grundsätzlich niemals über 1 ms liegen.

unlock_kernel

#include <linux/smp_lock.h>

void unlock_kernel(void);

Die Inline-Funktion gibt den »großen Kernel-Lock« frei. Der Kernel-Lock ist ein globales Spinlock, welches zum Schutz kritischer Abschnitte innerhalb des Kernels verwendet wird.

unregister_blkdev

#include <linux/fs.h>

int unregister_blkdev(unsigned int major_nr, const char *driver_name);

Diese Funktion wird vom Blockgeräte-Treiber in der Funktion cleanup_module aufgerufen. Sie meldet den Treiber wieder beim Betriebssystem ab. Der Treiber wird anhand der »major_nr« und des beim Anmelden des Treibers bereits schon einmal übergebenen Parameters »driver_name« identifiziert.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück. Ist entweder die Major-Nummer außerhalb des gültigen Bereiches oder der Gerätename »driver_name« falsch, gibt die Funktion »-EINVAL« zurück.

unregister_chrdev

#include <linux/fs.h>

int unregister_chrdev(unsigned int major_nr, const char *driver_name);

Diese Funktion wird vom zeichenorientierten Treiber in der Funktion cleanup_module aufgerufen. Sie meldet den Treiber wieder beim Betriebssystem ab. Der Treiber wird anhand der »major_nr« und des beim Anmelden des Treibers bereits schon einmal übergebenen Parameters »driver_name« identifiziert.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion »0« zurück. Ist entweder die Major-Nummer außerhalb des gültigen Bereiches oder der Gerätename »driver_name« falsch, gibt die Funktion »-EFAULT« zurück.

unregister_chrdev_region

#include <linux/fs.h>

void unregister_chrdev_region(dev_t from, unsigned count);

Die Funktion gibt »count« Gerätenummern beginnend bei »from« frei.

unregister_netdev

#include <linux/netdevice.h>

void unregister_netdev(struct net_device *dev);

Die Funktion entfernt den Netzkartentreiber »dev« wieder aus dem System. Im Vergleich zur Funktion unregister_netdevice sorgt die Funktion unregister_netdev für ein korrektes Locking der internen Datenstrukturen beim Entfernen der Struktur »dev«.

up

#include <asm/semaphore.h>

void up(struct semaphore *sem);

Diese Inline-Funktion wird beim Verlassen eines kritischen Abschnittes aufgerufen. Der Zähler des Semaphors »sem« wird inkrementiert. Ist er größer gleich Null, werden die auf das Semaphor wartenden Prozesse aufgeweckt.

Siehe auch: sema_init, down, down_interruptible und down_trylock.

up_read

#include <linux/rswem.h>

void up_read(struct rw_semaphore *sem);

Die Inline-Funktion gibt das zum Lesen gehaltene Lese-/Schreib-Semaphor »sem« wieder frei.

Siehe auch: init_rwsem, down_read, down_write, down_read_trylock, down_write_trylock, downgrade_write und up_write.

up_write

#include <linux/rwsem.h>

void up_write(struct rw_semaphore *sem);

Die Inline-Funktion gibt das zum Schreiben gehaltene Lese-/Schreib-Semaphor »sem« wieder frei.

Siehe auch: init_rwsem, down_read, down_write, down_read_trylock, down_write_trylock, downgrade_write und up_read.

usb_alloc_urb

#include <linux/usb.h>

struct urb *usb_alloc_urb(int iso_packets, int mem_flags);

Die Funktion erzeugt einen neuen URB. Falls ein URB für den Iso-Transfer erzeugt werden soll, wird die Anzahl der Iso-Pakete über den Parameter »iso_packets« angegeben. »Mem_flags« legt fest, mit welchem Flag die dynamische Speicherallokation erfolgt (siehe kmalloc). Abhängig von »mem_flags» kann die Funktion auch im Interrupt-Kontext verwendet werden. Zur Freigabe des URB wird später die Funktion usb_free_urb aufgerufen.

Rückgabewert. Die Funktion gibt die Adresse des erzeugten URB zurück, im Fehlerfall »NULL«.

usb_bulk_msg

#include <linux/usb.h>

int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout);

Die Funktion erzeugt einen Bulk-URB, sendet ihn an das Gerät »usb_dev« und wartet auf die Bearbeitung. Der Parameter »pipe« stellt den Endpunkt (innerhalb des Gerätes) dar, »data« den Zeiger auf die zu sendenden Daten und »len« die Anzahl der zu sendenden Daten. »Timeout« gibt die maximal zu wartende Zeit in Jiffies an; »0« wartet ohne Zeitüberwachung. Die Funktion darf nicht im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Im Erfolgsfall gibt die Funktion »0« zurück, ansonsten einen negativen Fehlercode. Die Anzahl der transferierten Bytes ist in »actual_length« abgelegt.

usb_control_msg

#include <linux/usb.h>

int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype, __u16 value, __u16 index, void *data, __u16 size, int timeout);

Die Funktion erstellt einen Control-URB, sendet ihn zum Gerät »dev« und wartet maximal »timeout« Jiffies auf die Bearbeitung. Der Parameter »pipe« spezifiziert die Geräteadresse, die Endpunktadresse und die Transferrichtung.

Rückgabewert. Im Erfolgsfall gibt die Funktion die Anzahl der gesendeten Bytes zurück, ansonsten einen negativen Fehlercode.

usb_deregister

#include <linux/usb.h>

void usb_deregister(struct usb_driver *driver);

Über diese Funktion meldet sich der USB-Treiber »driver« beim USB-Subsystem ab. Um die vom Treiber allozierten Minor-Nummern freizugeben, ist darüber hinaus die Funktion usb_deregister_dev aufzurufen.

usb_deregister_dev

#include <linux/usb.h>

void usb_deregister_dev(struct usb_interface *intf, struct usb_class_driver *class_driver);

Treiber, die die USB-Major-Nummer »180« verwenden, geben mit dieser Funktion die zuvor mit usb_register_dev reservierte Minor-Nummer wieder frei. Der Parameter »class_driver« spezifiziert den Treiber, der Parameter »intf« die zugehörige Minor-Nummer.

Ist das Device-Filesystem aktiviert, wird außerdem der Gerätedateieintrag wieder gelöscht.

USB_DEVICE

#include <linux/usb.h>

USB_DEVICE(__u16 vendor, __u16 product);

Das Makro dient zur Beschreibung eines spezifischen USB-Gerätes auf Basis des Herstellers »vendor« und der Produkt-ID »product«. Das Makro wird benötigt, um damit die Struktur struct usb_device_id zu besetzen. Diese Struktur ist in der Header-Datei <linux/mod_devicetable.h> deklariert.

static struct usb_device_id usbtestids[] = {
    { USB_DEVICE(USB_VENDOR_ID, USB_PRODUCT_ID) },
    { }                    /* Terminating entry */
};

Siehe auch USB_DEVICE_VER, USB_DEVICE_INFO und USB_INTERFACE_INFO.

Rückgabewert. Das Makro expandiert zum Initialisierungscode für ein Element vom Typ struct usb_device_id.

USB_DEVICE_INFO

#include <linux/usb.h>

USB_DEVICE_INFO(__u8 class, __u8 subclass, __u8 protocol);

Das Makro wird genutzt, um damit eine Struktur vom Typ struct usb_device_id (deklariert in der Header-Datei <linux/mod_devicetable.h>) zu erzeugen, die ein USB-Gerät aufgrund der Geräteklasse spezifiziert. Die Geräteklasse ist durch die Klasse »class«, die Unterklasse »subclass« und das Protokoll »protocol« gegeben.

Siehe auch USB_DEVICE, USB_DEVICE_VER, USB_INTERFACE_INFO.

Rückgabewert. Das Makro expandiert zum Initialisierungscode für ein Element vom Typ struct usb_device_id.

USB_DEVICE_VER

#include <linux/usb.h>

USB_DEVICE_VER(__u16 vendor, __u16 product, __u16 loversion, __u16 hiversion);

Das Makro dient zur Beschreibung eines spezifischen USB-Gerätes auf Basis des Herstellers »vendor«, der Produkt-ID »product« und der Version, die durch »loversion« und »hiversion« gegeben ist. Das Makro wird benötigt, um damit die in der Header-Datei <linux/mod_devicetable.h> deklarierte Struktur struct usb_device_id zu besetzen.

Siehe auch USB_DEVICE, USB_DEVICE_INFO und USB_INTERFACE_INFO.

Rückgabewert. Das Makro expandiert zum Initialisierungscode für ein Element vom Typ struct usb_device_id.

usb_fill_XXX_urb

#include <linux/usb.h>

void usb_fill_control_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, unsigned char *setup_packet, void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context);

void usb_fill_bulk_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context);

void usb_fill_int_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe, void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context, int interval);

Diese Inline-Funktionen initialisieren für jede der vier USB-Transferarten den Request-Block »urb«.

Die Parameter:

Parametername Bedeutung
»dev« Zeiger auf die zum »urb« gehörige struct usb_device.
»pipe« Die Endpunkt-Pipe.
»transfer_buffer« Zeiger auf den Transfer-Buffer.
»buffer_length« Länge des Transfer-Buffers.
»complete« Zeiger auf die Completion-Funktion, die aufgerufen wird, sobald der »urb« bearbeitet wurde.
»context« Der Kontext des »urb«.
»interval« Das Intervall, auf das der »urb« gesetzt werden soll.
»setup_packet« Zeiger auf das Setup-Paket.

usb_free_urb

#include <linux/usb.h>

void usb_free_urb(struct urb *urb);

Die Funktion gibt den URB »urb« wieder frei. Der mit dem URB verknüpfte Speicherbereich wird erst dann freigegeben, wenn niemand mehr auf diesen zugreift.

usb_get_descriptor

#include <linux/usb.h>

int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size);

Die Funktion schickt dem Gerät »dev« ein »GET_DESCRIPTOR«. »type« spezifiziert den Deskriptor-Typ, »index« den Index, »buf« den Speicherbereich für das Ergebnis und »size« die Größe von »buf«.

Die Funktion arbeitet synchron (wartet auf das Ergebnis) und darf daher nicht im Interrupt-Kontext verwendet werden.

Rückgabewert. Die Funktion gibt die Anzahl der empfangenen Bytes im Erfolgsfall zurück, ansonsten den Statuscode, der von der unterliegenden Funktion usb_control_msg zurückgegeben wird.

usb_get_device_descriptor

#include <linux/usb.h>

int usb_get_device_descriptor(struct usb_device *dev);

Die Funktion fordert vom Gerät »dev« einen »USB_DT_DEVICE«-Deskriptor. Sie verwendet dazu die Funktion usb_get_descriptor.

Rückgabewert. Die Funktion gibt die Anzahl der empfangenen Bytes im Erfolgsfall zurück, ansonsten den Statuscode, der von der unterliegenden Funktion usb_control_msg zurückgegeben wird.

usb_get_status

#include <linux/usb.h>

int usb_get_status(struct usb_device *dev, int type, int target, void *data);

Die Funktion dient dazu, den Zustand des Gerätes, des Interfaces und des Endpunktes zu evaluieren. Normalerweise wird die Funktion verwendet, um festzustellen, ob ein Gerät eine eigene Stromversorgung besitzt, die Remote-Wakeup-Funktion eingeschaltet hat oder ob ein Bulk- oder Interrupt-Endpunkt »stalled« ist.

Da die Funktion synchron arbeitet, darf sie nicht im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion die Anzahl der empfangenen Bytes zurück, ansonsten einen Fehlercode.

usb_get_string

#include <linux/usb.h>

int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size);

Die Funktion holt den String an Index »index« (mit der zugehörigen »langid«), der in UTF-16LE (Unicode) kodiert ist, vom Gerät »dev«. Der String wird in »buf« abgelegt, wobei »buf« maximal »size« Bytes zur Verfügung stellt. Die Funktion usb_string wird oftmals verwendet, um den String in eine druckbare Form zu wandeln. Da die Funktion synchron arbeitet, darf sie nicht im Interrupt-Kontext verwendet werden.

Strings können in Geräten, Konfigurationen, Interfaces oder anderen Deskriptoren ausgewählt werden.

Rückgabewert. Im fehlerfreien Fall gibt die Funktion die Anzahl der empfangenen Bytes zurück, ansonsten einen Fehlercode.

USB_INTERFACE_INFO

#include <linux/usb.h>

USB_INTERFACE_INFO(__u8 interfaceclass, __u8 interfacesubclass, __u8 interfaceprotocol);

Das Makro wird genutzt, um damit eine Struktur vom Typ struct usb_device_id (deklariert in der Header-Datei <linux/mod_devicetable.h>) zu erzeugen, die ein USB-Gerät aufgrund der einer Klasse von Interfaces spezifiziert. Die Interface-Klasse ist durch »interfaceclass«, die Unterklasse »interfacesubclass« und das Protokoll »interfaceprotocol« gegeben.

Siehe auch USB_DEVICE, USB_DEVICE_VER, USB_DEVICE_INFO und

Rückgabewert. Das Makro expandiert zum Initialisierungscode für ein Element vom Typ struct usb_device_id.

usb_rcvctrlpipe

#include <linux/usb.h>

int usb_rcvctrlpipe(struct usb_device *dev, unsigned int endpoint);

Der Endpunkt wird in Form einer so genannten Pipe angegeben, ein Bitfeld, das neben der Geräteadresse (durch »dev« gegeben), der Endpunktadresse (Nummer, durch »endpoint« gegeben) und der Transferrichtung noch die Transferart kodiert. Dem Programmierer steht ein Set von Makros zur Verfügung, um die Kodierung einer Pipe nicht selbst vornehmen zu müssen: der Name des Makros setzt sich zusammen aus der Vorsilbe usb_, der Transferrichtung snd oder rcv und der Transferart ctrl, bulk, iso oder int.

Rückgabewert. Das Makro kodiert die Pipe.

usb_register

#include <linux/usb.h>

int usb_register(struct usb_driver *new_driver);

Über diese Funktion meldet sich ein Treiber beim USB-Subsystem an. In der Struktur »new_driver« wird der Treiber mit seiner Probe-Funktion und seiner Remove-Funktion spezifiziert.

Rückgabewert. Die Funktion gibt im Erfolgsfall »0« zurück, ansonsten einen Fehlercode.

usb_register_dev

#include <linux/usb.h>

int usb_register_dev(struct usb_interface *intf, struct usb_class_driver *class_driver);

Mit Hilfe dieser Funktion kann sich ein Treiber vom USB-Subsystem eine Minor-Nummer zuweisen lassen. Die Minor-Nummer wird dabei in das Feld »intf->minor« abgelegt. Beim Zugriff auf die entsprechende Minor-Nummer werden die in »class_driver« angegebenen Treiberfunktionen aufgerufen. Die zugehörige Major-Nummer des USB-Subsystems ist »180«.

Wird die Minor-Nummer nicht mehr gebraucht, muss die Funktion usb_deregister_dev aufgerufen werden.

Ist das Device-Filesystem aktiviert, wird im Geräte-Verzeichnis eine Gerätedatei angelegt. Dazu werden die Daten aus der »class_driver« herangezogen.

Rückgabewert. Die Funktion gibt »0« zurück, falls kein Fehler aufgetreten ist, ansonsten »-EINVAL«.

usb_set_configuration

#include <linux/usb.h>

int usb_set_configuration(struct usb_device *dev, int configuration);

Die Funktion wählt die Konfiguration »configuration« im Gerät »dev« aus. Da die Funktion synchron arbeitet, darf sie nicht im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Die Funktion gibt im Erfolgsfall »0« zurück, ansonsten einen Fehlercode.

usb_set_interface

#include <linux/usb.h>

int usb_set_interface(struct usb_device *dev, int interface, int alternate);

Diese Funktion setzt das Interface »interface« auf die Einstellung »alternate« des Gerätes »dev«. Die Funktion darf nicht im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Die Funktion gibt »0« im fehlerfreien Fall, ansonsten den Fehlercode der unterliegenden Funktion usb_control_msg zurück.

usb_string

#include <linux/usb.h>

int usb_string(struct usb_device *dev, int index, char *buf, size_t size);

Die Funktion konvertiert den UTF-16LE-kodierten String (zurückgegeben von der Funktion usb_get_string) in einen null-terminierten, IOS-8859-1-kodierten String. Die Funktion darf nicht im Interrupt-Kontext aufgerufen werden.

Rückgabewert. Falls der Rückgabewert positiv ist, handelt es sich um die Länge des Strings. Ist der Rückgabewert negativ, stellt er den Statuscode der Funktion usb_control_msg dar.

usb_submit_urb

#include <linux/usb.h>

int usb_submit_urb(struct urb *urb, int mem_flags);

Diese Funktion startet einen asynchronen Transfer (»urb«) zu einem Endpunkt. Der Parameter »mem_flags« legt fest, auf welche Art der für den Transfer notwendige Speicher alloziert wird (siehe kmalloc). Nach Abschluss des Transfers ruft das USB-Subsystem die im URB spezifizierte Complete-Funktion auf. Dabei werden die drei Fertigstellungsarten Erfolg, Fehler und Trennen (unlink) unterschieden.

Rückgabewert. Bei Erfolg gibt die Funktion »0« zurück, ansonsten einen negativen Fehlercode. Bei erfolgreichem Abschluss wird die Complete-Funktion genau einmal aufgerufen. Danach darf der URB direkt wieder verwendet werden.

usb_unlink_urb

#include <linux/usb.h>

int usb_unlink_urb(struct urb *urb);

Die Funktion bricht den durch »urb« repräsentierten, bereits gestarteten Transfer wieder ab. Nach Abbruch wird vom USB-Subsystem die Complete-Funktion mit einem entsprechenden Status-Code aufgerufen. Falls das »URB_ASYNC_UNLINK«-Transferflag gelöscht ist, arbeitet die Funktion synchron. In diesem Fall darf sie nicht aus dem Interrupt-Kontext heraus aufgerufen werden.

Rückgabewert. Im synchronen Modus gibt die Funktion bei Erfolg »0« zurück; jeder andere Wert bedeutet Fehler. Die Complete-Funktion liest in diesem Fall den Statuswert »urb->status« »-ENOENT«.

Im asynchronen Modus gibt die Funktion bei Erfolg »-EINPROGRESS« zurück. Die Complete-Funktion liest in diesem Fall den Statuswert »urb->status« »-ECONNRESET«. Jeder andere Wert bedeutet Fehler.

vfree

#include <linux/vmalloc.h>

void vfree(void *address);

Über diese Funktion wird der durch vmalloc zuvor reservierte Speicherbereich mit der Startadresse »address« wieder freigegeben.

vmalloc

#include <linux/vmalloc.h>

void *vmalloc(unsigned long size);

Über diese Funktion kann vom Kernel dynamisch Speicher der Länge »size« alloziert werden. Die Funktion ist in der Lage, auch größere Speicherbereiche zu allozieren. Die Funktion legt den Aufrufer möglicherweise schlafen. Daher ist die Funktion nur im Prozesskontext zu verwenden.

Rückgabewert. Die Funktion gibt »NULL« zurück, falls kein Speicher zur Verfügung steht.

wait_event

#include <linux/wait.h>

void wait_event(wait_queue_head_t waitqueue, condition);

Ist die Bedingung »condition« nicht erfüllt, wartet der aktuelle Prozess, bis er aufgeweckt wird (entweder durch wake_up oder wake_up_interruptible) und die Bedingung erfüllt ist.

wait_event_interruptible

#include <linux/wait.h>

int wait_event_interruptible (wait_queue_head_t wait_queue, condition);

Dieses Makro legt einen Prozess auf die Wait-Queue »wait_queue« so lange schlafen, bis die Bedingung »condition« erfüllt ist.

    if( wait_event_interruptible( read_queue, (readptr>writeptr) ) )
        return -ERESTART;

Die Bearbeitung wird durch Signale unterbrochen.

Das Makro versetzt den aktiven Prozess (current) in den Zustand Warten (INTERRUPTIBLE), falls die Bedingung »condition« nicht erfüllt ist.

Rückgabewert. Die Funktion gibt »0« zurück, falls die Wartebedingung erfüllt ist, und einen Wert ungleich Null, falls die Funktion unterbrochen wurde. Wird der wartende Prozess durch ein Signal aufgeweckt, gibt die Funktion »-ERESTARTSYS« zurück.

wait_event_interruptible_timeout

#include <linux/wait.h>

int wait_event_interruptible_timeout(wait_queue_head_t waitqueue, condition, long timeout);

Das Makro wait_event_interruptible_timeout versetzt den zugehörigen Prozess in den Zustand Warten (INTERRUPTIBLE), wenn die Bedingung »condition« nicht erfüllt ist. Das Makro wird erst dann abgebrochen, wenn entweder ein Signal angekommen ist (in diesem Fall gibt das Makro »-ERESTARTSYS« zurück) oder die Zeit »timeout« (angegeben in Jiffies) abgelaufen ist und zugleich die Bedingung »condition« erfüllt ist. Ist die Zeit abgelaufen, aber die Bedingung noch nicht erfüllt, wird das Makro nicht beendet.

Rückgabewert. Das Makro gibt »0« zurück, falls die Bedingung erfüllt ist oder falls die Zeit abgelaufen ist. Die Funktion gibt »-ERESTARTSYS« zurück, falls das Warten durch ein Signal unterbrochen wurde.

wait_for_completion

#include <linux/completion.h>

void wait_for_completion(struct completion *x);

Mit dieser Funktion wartet der Prozess (Treiberinstanz, Kernel-Thread) auf die Signalisierung des Completion-Objekts »x«. Ist die Signalisierung vor Aufruf der Funktion erfolgt, legt sich der Prozess nicht schlafen. Ansonsten wartet der Prozess, bis die Signalisierung erfolgt ist. Jedes wait_for_completion korrespondiert genau mit einem Aufruf der Funktion complete. Somit kann ein Completion-Objekt verwendet werden, um mehrfach darauf zu warten.

Siehe auch: DECLARE_COMPLETION, init_completion, complete, complete_all und complete_and_exit.

wake_up

#include <linux/wait.h>

void wake_up(wait_queue_head_t *wait_queue);

Diese Funktion wird zum Aufwecken des Treibers bzw. der mit dem Treiber assoziierten Tasks verwendet, die sich auf die Queue »wait_queue« schlafen gelegt haben.

Im Vergleich zur Funktion wake_up_interruptible werden durch die Funktion wake_up alle schlafenden Prozesse aufgeweckt. wake_up_interruptible weckt dagegen nur Prozesse auf, die sich über die Funktion wait_event_interruptible schlafen gelegt haben.

wake_up_interruptible

#include <linux/wait.h>

void wake_up_interruptible(wait_queue_head_t *wait_queue);

Diese Funktion wird zum Aufwecken des Treibers bzw. der mit dem Treiber assoziierten Tasks verwendet, die sich auf die Queue »wait_queue« schlafen gelegt haben.

Durch die Funktion wake_up_interruptible werden nur die Prozesse aufgeweckt, die sich durch Aufruf der Funktion wait_event_interruptible schlafen gelegt haben. Dagegen weckt der Aufruf der Funktion wake_up alle schlafenden Prozesse auf.

WARN_ON

#include <asm/bug.h>

void WARN_ON(condition);

Falls die Bedingung »condition« erfüllt ist, erzeugt der Kernel eine Warnmeldung. Dabei werden der Dateiname und die Zeilennummer ausgegeben, in der die Warnung erzeugt wurde. Die Warnmeldung wird typischerweise in den Syslogs abgelegt. Die Bedingung wird als normaler Ausdruck der Programmiersprache C definiert.

Siehe auch: BUG_ON.

wmb

#include <asm/system.h>

void wmb(void);

Write Barrier: Vor dem nächsten Schreibauftrag werden sämtliche bisher angestoßenen Schreibaufträge durchgeführt.

Siehe auch: mb, rmb und barrier.

write[bwl]

#include <asm/io.h>

void writeb(u8 value, void *addr);

void writew(u16 value, void *addr);

void writel(u32 value, void *addr);

Die Makros schreiben auf die Speicher-Adresse »addr« den Wert »value«.

write_lock

#include <linux/spinlock.h>

void write_lock(rwlock_t *lock);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Schreiben. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion write_unlock verwendet werden.

write_lock_bh

#include <linux/spinlock.h>

void write_lock_bh(rwlock_t *lock);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Schreiben und sperrt Softirqs. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Mit dieser Funktion kann ein kritischer Abschnitt geschützt werden, an dem Tasklets und Timer beteiligt sind. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion write_unlock_bh verwendet werden.

write_lock_irq

#include <linux/spinlock.h>

void write_lock_irq(rwlock_t *lock);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Schreiben und sperrt Interrupts. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Mit dieser Funktion kann ein kritischer Abschnitt geschützt werden, an dem ISRs, Tasklets und Timer beteiligt sind. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion write_unlock_irq verwendet werden.

write_lock_irqsave

#include <linux/spinlock.h>

void write_lock_irqsave(rwlock_t *lock, unsigned int iflags);

Das Makro reserviert das Lese-/Schreib-Lock »lock« zum Schreiben, sichert die Interruptflags in »iflags« und sperrt Interrupts. Falls das Lese-/Schreib-Lock zur Zeit des Aufrufs gesperrt ist, wird so lange (aktiv) gewartet, bis das Lese-/Schreib-Lock frei ist. Mit dieser Funktion kann ein kritischer Abschnitt geschützt werden, an dem ISRs, Tasklets und Timer beteiligt sind. Zur Freigabe des Lese-/Schreib-Locks muss die Funktion write_unlock_irqrestore verwendet werden.

write_seqlock

#include <linux/seqlock.h>

void write_seqlock(seqlock_t *sl);

Die Inline-Funktion reserviert das Sequence-Lock »sl« zum Schreiben. Falls bereits eine andere Instanz »sl« für den schreibenden Zugriff reserviert hat, wird so lange (aktiv) gewartet, bis das Sequence-Lock wieder freigegeben worden ist. Zur Freigabe des Sequence-Locks muss die Funktion write_sequnlock aufgerufen werden.

write_seqlock_bh

#include <linux/seqlock.h>

void write_seqlock_bh(seqlock_t *sl);

Die Inline-Funktion sperrt die Softirqs und reserviert das Sequence-Lock »sl« zum Schreiben. Falls bereits eine andere Instanz »sl« für den schreibenden Zugriff reserviert hat, wird so lange (aktiv) gewartet, bis das Sequence-Lock wieder freigegeben worden ist. Zur Freigabe des Sequence-Locks muss die Funktion write_sequnlock_bh aufgerufen werden.

write_seqlock_irq

#include <linux/seqlock.h>

void write_seqlock_irq(seqlock_t *sl);

Die Inline-Funktion sperrt die Interrupts und reserviert das Sequence-Lock »sl« zum Schreiben. Falls bereits eine andere Instanz »sl« für den schreibenden Zugriff reserviert hat, wird so lange (aktiv) gewartet, bis das Sequence-Lock wieder freigegeben worden ist. Zur Freigabe des Sequence-Locks muss die Funktion write_sequnlock_irq aufgerufen werden.

write_seqlock_irqsave

#include <linux/seqlock.h>

void write_seqlock_irqsave(seqlock_t *sl, unsignedn long iflags);

Die Inline-Funktion sichert die Interrupt-Flags, sperrt die Interrupts und reserviert das Sequence-Lock »sl« zum Schreiben. Falls bereits eine andere Instanz »sl« für den schreibenden Zugriff reserviert hat, wird so lange (aktiv) gewartet, bis das Sequence-Lock wieder freigegeben worden ist. Zur Freigabe des Sequence-Locks muss die Funktion write_sequnlock_irqrestore aufgerufen werden.

write_sequnlock

#include <linux/seqlock.h>

void write_sequnlock(seqlock_t *sl);

Die Inline-Funktion gibt das zuvor mit write_seqlock reservierte Sequence-Lock »sl« frei.

write_sequnlock_bh

#include <linux/seqlock.h>

void write_sequnlock_bh(seqlock_t *sl);

Die Inline-Funktion gibt die Softirqs und das zuvor mit write_seqlock_bh reservierte Sequence-Lock »sl« frei.

write_sequnlock_irq

#include <linux/seqlock.h>

void write_sequnlock_irq(seqlock_t *sl);

Die Inline-Funktion gibt die Interrupts und das zuvor mit write_seqlock_irq reservierte Sequence-Lock »sl« frei.

write_sequnlock_irqrestore

#include <linux/seqlock.h>

void write_sequnlock_irqrestore(seqlock_t *sl, unsigned long iflags);

Die Inline-Funktion restauriert die Interrupt-Flags mit »iflags« und gibt das zuvor mit write_seqlock_irqsave reservierte Sequence-Lock »sl« frei.

write_tryseqlock

#include <linux/seqlock.h>

int write_tryseqlock(seqlock_t *sl);

Diese Inline-Funktion wird aufgerufen, wenn der durch »sl« geschützte kritische Abschnitt zum Schreiben betreten werden soll. Ist das Sequence-Lock belegt, gibt die Funktion »0« zurück. Der kritische Abschnitt darf dann nicht betreten werden.

Rückgabewert. Ein Rückgabewert von »0« bedeutet, dass das Sequence-Lock bereits belegt ist. Bei jedem anderen Rückgabewert darf der kritische Abschnitt betreten werden.

write_unlock

#include <linux/spinlock.h>

void write_unlock(rwlock_t *lock);

Das Makro gibt das zuvor mit write_lock zum Schreiben reservierte Lese-/Schreib-Spinlock »lock« frei.

write_unlock_bh

#include <linux/spinlock.h>

void write_unlock_bh(rwlock_t *lock);

Das Makro gibt das zuvor mit write_lock_bh zum Schreiben reservierte Lese-/Schreib-Spinlock »lock« frei.

write_unlock_irq

#include <linux/spinlock.h>

void write_unlock_irq(rwlock_t *lock);

Das Makro gibt das zuvor mit write_lock_irq zum Schreiben reservierte Lese-/Schreib-Spinlock »lock« frei. Nach Aufruf der Funktion sind Interrupts zugelassen.

write_unlock_irqrestore

#include <linux/spinlock.h>

void write_unlock_irqrestore(rwlock_t *lock, unsigned long iflags);

Das Makro gibt das zuvor mit write_lock_irqsave zum Schreiben reservierte Lese-/Schreib-Spinlock »lock« frei. Außerdem werden die Interrupt-Flags gemäß »iflags« restauriert.

XXXXsetup

#include <linux/netdevice.h>

void XXXXsetup(struct net_device *dev);

Funktion zur Initialisierung der Struktur »dev« mit Kommunikationssystem-spezifischen Werten.

XXXX steht für Ethernet, FDDI, Token Ring oder Fibre Channel. Also lauten die Ausprägungen dieser Funktionen:


Lizenz