Systemsoftware > Treiber > Flashcards

Treiber Flashcards

Treiber Programmierung (74 cards)

Study These Flashcards
1
Q

Funktion um Speicher für ein CharDev zu reservieren.

A

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
Bsp:
alloc_chrdev_region(&dev, 0, 1, “hello”)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

Treiber Objekt beim Kernel anmelden. Objekt reservieren.

A

cdev_alloc()
Bsp:
driver_object = cdev_alloc()

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

Treiber Klasse erstellen.

A

class_create(owner, name) -> Ist als Makro definiert.
Bsp:
cl = class_create(THIS_MODULE, “hello”);

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

Instanz des Treibers beim Kernel erstellen.

A

struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, …)
Bsp:
device_create(cl, NULL, dev, NULL, “hello”)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

Treiber beim System abmelden.

A

void kobject_put(struct kobject *kobj)
Bsp:
kobject_put(&driver_object->kobj);

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

Nenne Systemfunktionen?

A
  • close()
  • read()
  • write()
  • seek()
  • select()
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

Was passiert bei der Funktion open() ?

A
  • Prüfen ob der Treiber geladen ist
  • Zugriffsrechte prüfen
  • welcher Zugriff auf das gerät wird verlangt
  • Rückgabewert: Filedeskriptor
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

Treiber dem System hinzufügen (dem Kernel Bescheid geben dass ein neuer Treiber da ist).

A

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
Bsp:
cdev_add(driver_object, dev, 1)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

Reservierten Speicher für den Treiber freigeben. (4 Funktionen)

A 
void cdev_del(struct cdev *p)
void device_destroy(struct class *class, dev_t devt)
void class_destroy(struct class *cls)
static inline void unregister_chrdev(unsigned int major, const char *name)
Bsp:
cdev_del(driver_object);
device_destroy(cl, dev);
class_destroy(cl);
unregister_chrdev_region(dev, 1);
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

Treiber write Funktion

A

static ssize_t driver_write(struct file* instanz, const char* user, size_t conut, loff_t* offset)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

Was passiert bei der Funktion read() ?

A
  • Lesen von Daten

- Rückgabewert: Anzahl gelesener Bytes / Fehlercode

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

Was passiert bei der Funktion write() ?

A
  • Schreiben von Daten

- Rückgabewert: Anzahl an geschreibenen Bytes/Fehlercode

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

Was passiert bei der Funktion ioctl() ?

A
  • Funktion um mit dem Treiber zu kommunizieren

- Unterstützt frei definierbare Kommandos und Parameter

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

Was passiert bei der Funktion mmap() ?

A
  • Funktion, um Speicherbereiche eines Geräts in den Adressraum einer Applikation einzublenden.
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

Was passiert bei der Funktion seek()/poll() ?

A
  • Funktion um zu prüfen ob an einem Gerät Daten zum lesen bereit liegen.
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

Treiber read Funktion.

A

static ssize_t driver_read(struct file* instanz, char* user, size_t count, loff_t* offset)

struct file *instanz: Info über die Treiberinstanz
char *user: Speicherbereich im User-Space
size_t count: Größe des Buffers im User-Space
loff_t offs: Offset

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

Erklären sie das Verhalten wenn ein Treiber im blocking mode ist?

A

Beim “blocking mode” wird die Application schlafen gelegt sobald keine Daten geschrieben oder gelesen werden können.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

Treiber close Funktion

A

static int driver_close(struct inode * geraetedatei, struct file *instanz)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q

Treiber writeFunktion

A

static ssize_t driver_write(struct file* instanz, const char* user, size_t conut, loff_t* offset)

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

Treiber Funktionen zum FileOperations struct (struct fileoperations) hinzufügen.

A 
static struct file_operations fops = {
        .owner = THIS_MODULE,
        .open = driver_open,
        .release = driver_close,
	.read = driver_read,
	.write = driver_write,
};
How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

Warum müssen die Treiber Funktionen in das struct fileoperations eingetragen werden?

A

Der Kernel benötigt die Adressen der Funktionen des Treibers, damit er diese bei einem Systemcall aufrufen kann. Das struct fileoperations stellt die Verbindung für den Kernel zwischen der Treiberfunktion und dem Treiber her.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
22
Q

Nenne die unterschiedlichen Kontexte in denen Treibercode ausgeführt werden kann.

A

Userkontext
Prozesskontext
Kernelkontext
Interruptkontext

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
23
Q

Nenne Funktionen um den Treiber in das Betriebssystem einzubinden.

A

init_module
cleanup_module
probe
remove

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
24
Q

Nenne Funktionen, die durch das Betriebssystem oder die Hardware getriggert werden.

A

ISR
Soft-IRQ´s
Kernel-Threads

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
25
Welche Zugriffsarten gibt es um auf ein Gerät zu zugreifen?
- > blocking mode | - > non blocking mode
26
Erklären sie das Verhalten wenn ein Treiber im blocking mode ist?
Beim "blocking mode" wird die Application schlafen gelegt sobald keine Daten geschrieben oder gelesen werden können.
27
Erklären sie das Verhalten wenn ein Treiber im non blocking mode ist?
Beim "non blocking mode" wird der Aufruf direkt zurück kommen mit dem Fehlercode -EAGAIN.
28
Was gibt der Kontext an in dem Programmcode ausgeführt wird (Prozesskontext, etc.).
Der Kontext (Umgebung) gibt an, auf welche Daten und Dienste ein Codefragment Zugriff hat.
29
Beschreibe den Interrupt-Kontext.
Limitierte Funktionsauswahl, insbesondere kein „Schlafen legen“ und kein Zugriff auf Applikations-Speicherbereiche. ISRs, Soft-IRQs, Tasklets und Timer. GFP_ATOMIC
30
Beschreibe den Kernel-Kontext.
Zugriff auf sämtliche Funktionen des Kernels, inklusive „Schlafen legen“. Kernel-Threads, Workqueues, Event-Workqueue GFP_KERNEL
31
Was für Aufgaben hat exit_module()?
- Freigeben der allozierten Systemressourcen | - Abmelden des Modules beim System.
32
Anmelden einer Hardware ISR, inklusiv Beispiel.
Mit request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev) wird eine ISR beim System angemeldet. Bsp: request_irq(dev->irq, driver_isr, IRQF_DISABLED | IRQF_SHARED, "pci_drv", dev)
33
Was sind Soft-IRQ`s?
Werden im Interrupt-Kontext abgearbeitet | Abarbeitungszeitpunkt direkt nach einer ISR
34
Was gibt die Minornumber an?
Die Minornumber dient zu Unterscheidung der einzelnen logischen Geräte.
35
Was passiert bei folgendem Befehl "insmod"?
Es wird ein Liste angezeigt mit den geladenen Modulen.
36
Wie greife ich auf die Major und Minor number zu?
``` minor = MINOR(dev_t); major= MAJOR(dev_t); ```
37
Was für Aufgaben hat exit_module()?
- Freigeben der allozierten Systemressourcen | - Abmelden des Modules beim System.
38
Was muss in der Treiberfunktion driver_close() beachtet werden?
- zuvor allozierten Ressourcen frei geben. - Geräte counter zurück setzten - Rückgabewert: 0
39
Was passiert bei der Treiberfunktion driver_read?
- Datentransfer zwischen Kernel-User Space. | - Rückgabewert: Anzahl gelesener Bytes / Fehlercode
40
Funktionen zum Datentransfer zwischen User und Kernel Space.
- copy_to_user( to, from, len ) | - copy_from_user( to, from, len )
41
Bei einem Tasklet kann eine Race-Condition auftreten. Welche?
Wird der Tasklet-Code entladen bevor er aufgerufen wird, würde der Kernel nach einer ISR Code ausführen, der nicht mehr vorhanden ist.
42
Damit im Betriebssystem die richtige driver_read() Funktion gefunden wird, muss welches Verfahren angewendet werden?
- Der Treiber muss sich beim IO-Subsystem mit einer eindeutigen Kennung anmelden. alt: Major Minor Nummer neu: Gerätenummer (32 bit)
43
Was gibt die Majornumber an?
Die Majornumber dient zur Identifikation des Treibers.
44
Was gibt die Minornumber an?
Die Minornumber dient zu Unterscheidung der einzelnen logischen Geräte.
45
Welcher type ist dev_t ?
dev_t ist ein typdef der wiederum aus einem u32 besteht. Dies ist die Gerätenummer.
46
Wie greife ich auf die Major und Minor number zu?
``` minor = MINOR(dev_t); major= MAJOR(dev_t); ```
47
Was macht int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)?
alloc_chrdev_region registriert eine Reihe von Gerätenummern. Die Majornummer wird dabei dynamisch vom System vergeben.
48
Was macht int register_chrdev_region(dev_t from, unsigned count, const char *name)?
register_chrdev_region registriert eine Reihe von Gerätenummern angefangen bei dem Parameter "from". Es muss eine Gerätnummer vergeben worden sein.
49
Was muss in der Treiberfunktion driver_open() beachtet werden?
- Zugriffsüberwachung (Wie viel mal darf das Gerät geöffnet werden, Wie wird auf das Gerät zugegriffen lesend schreiben) - Initialisierung
50
Was ist ein Kernel-Thread
Ein Thread, der im Kernel abläuft und keine Ressourcen im Userland besitzt. Er besitzt einen eigenen PCB.
51
Was ist ein Kernel-Thread
Ein Thread, der im Kernel abläuft und keine Ressourcen im Userland besitzt.
52
Beschreibe kurz eine Race Condition, die bei Kernel Threads auftreten kann.
Ein Thread muss beendet sein, bevor der zugehörige Code entfernt wurde. D.h. auch, dass der Treiber evtl. auf die Beendigung eines Threads warten muss, bevor er entladen wird.
53
Was passiert bei der Treiberfunktion driver_read?
- Datentransfer zwischen Kernel-User space. | - Rückgabewert: Anzahl gelesener Bytes / Fehlercode
54
Funktionen zum Datentransfer zwischen User und Kernel Space.
- copy_to_user( to, from, len ) | - copy_from_user( to, from, len )
55
Was sind Workqueues?
Workqueues sind „vorgefertigte“ Kernel-Threads, in deren Kontext Funktionen (einmal) abgearbeitet werden.
56
Wie kann man einen Kernel-Thread starten, nach dem er erzeugt wurde?
Mit wake_up_process(thread_id) wird eine wartender Thread aktiviert und rechenbereit gemacht.
57
Welche Möglichkeiten gibt es einen Kernel-Thread zu erzeugen?
1. Möglichkeit kthread_create(thread_code, data, "mykthread") Diese Funktion erzeugt einen Thread, der noch nicht aktiv ist und damit vom Scheduler nicht ausgewählt wird. 2. Möglichkeit kthread_run(thread_code, data, "mykthread") wird ein Thread erzeugt und rechenbereit gesetzt.
58
Erzeugen einer Workqueue.
Mit create:workqueue(name). Damit die workqueue aber arbeitet, muss sie mit queue_work(wq, &work) gestartet werden.
59
Was passiert bei der Treiberfunktion driver_write?
- Datentransfer zwischen Kernel-User Space. | - Rückgabewert: Anzahl transferierter Bytes / Fehlercode
60
Erzwingen der Abarbeitung einer workqueue.
flush_workqueue(wq)
61
Kann es bei einer wait_event_interruptible() zu einer Race-Condition kommen?
Ja kann es, wenn der befehl wake_up() vor der ISR kommt. Durch wake_up() läuft die Anwendung zu ende und entlädt den Treiber.
62
Welche Arten von "Arbeit" nimmt eine workqueue entgegen?
Eine workqueue nimmt Arbeit von dem Typ struct work entgegen.
63
Wie wird Arbeit für eine workqueue angelegt?
Statisch mit dem Makro DECLARE_WORK(work, work_func, data)
64
Auf welche Schutzmechanismen kann innerhalb des Prozesskontext zurückgegriffen werden?
Atomare Operationen Spinlocks Mutexte Semaphore
65
Auf welche Schutzmechanismen kann innerhalb des Interruptkontextes zurückgegriffen werden?
Atomare Operationen | Spinlocks
66
Auf welche Schutzmechanismen kann innerhalb des Kernelkontext und Prozesskontext zurückgegriffen werden?
Atomare Operationen Spinlocks Mutexte Semaphore
67
Funktionen die den Taskzustand beeinflussen.
wait_event_interruptible( wait_queue, Bedingung) schläft genau so lange, bis entweder die Wartebedingung erfüllt ist oder aber ein Signal den Prozess aufweckt (return -ERESTARTSYS;).
68
Kann es bei einer wait_event_interruptible() zu einer Race-Condition kommen?
Ja kann es, wenn der befehl wake_up() vor der ISR kommt. Durch wake_up() läuft die Anwendung zu ende und entlädt den Treiber.
69
Nenne ein Beispiel bei der Verwendung eines Mutex.
mutex_lock(my_mutex) /*kritischer Bereich*/ mutex_unlock(my_mutex)
70
Mutexe können auch unterbrechbar gelockt werden.
``` if(mutex_lock_killable(my_mutex)) { return -ERESTARTSYS; } /*kritischer Bereich*/ mutex_unlock(my_mutext) ```
71
Wie wird ein Mutex definiert?
DEFINE_MUTEX(my_mutex)
72
Bei der Verwendung sind Mutexe den Semaphoren vorzuziehen. Warum?
Mutexe sind speichereffizienter als Semaphore.
73
Wann verwendet man spinlock_irqsave()/spin_lock_irqrestore() und spin_lock()/spin_unlock()?
Man verwendet spin_lock() und spin_unlock() wenn die geteilte Ressource nur im Prozesskontext verwendet wird. Wird die Ressource auch im Interruptkontext verwendet, muss im Prozesskontext spin_lock_irqsave() und spin_lock_irgrestore() benutzt werden.
74
Was machen spin_lock_bh() und spin_unlock_bh().
Die beiden Funktionen schalten Soft-IRQ´s ab lassen aber Hardware-Interrupts zu.
Systemsoftware
flashcards
Decks in class (9)
# Cards
Brainscape helps you reach your goals faster, through stronger study habits.
© 2026 Bold Learning Solutions. Terms and Conditions