Pentru rezolvarea laboratorului, vom lucra în același director din care pornim mașina virtuală (~/so2/linux/tools/labs).

Pașii de rezolvare sunt următorii:

• pregătirea scheletului de laborator
• compilarea modulelor de Kernel
• copierea modulelor pe mașina virtuală
• pornirea mașinii virtuale și testarea modulelor

Scheletul de laborator este generat din sursele din directorul tools/labs/templates. Putem genera scheletele pentru toate laboratoarele folosind următoarea comanda:

tools/labs $ make skels

Pentru a genera scheletul pentru un singur laborator, vom folosi variabila de mediu LABS:

tools/labs $ make clean
tools/labs $ LABS=<lab name> make skels

Similar, putem genera și scheletul pentru un singur exercițiu, atribuind valoarea <lab_name>/<task_name> variabilei LABS.

Comanda make build compilează toate modulele din directorul skels.

student@eg106:~/so2/linux/tools/labs$ make build
echo "# autogenerated, do not edit " > skels/Kbuild
echo "ccflags-y += -Wno-unused-function -Wno-unused-label -Wno-unused-variable " >> skels/Kbuild
for i in ./interrupts; do echo "obj-m += $i/" >> skels/Kbuild; done
...

Putem copia modulele generate pe mașina virtuală folosind target-ul copy al comenzii make, atunci când mașina virtuală este oprită.

student@eg106:~/so2/linux/tools/labs$ make copy
student@eg106:~/so2/linux/tools/labs$ make boot

Alternativ, putem copia fișierele prin scp, pentru e evita repornirea mașinii virtuale. Pentru detalii despre folosirea interacțiunea prin rețea cu mașina virtuală citiți Interacțiunea cu mașina virtuală.

Modulele generate sunt copiate pe mașina virtuală în directorul /home/root/skels/<lab_name>.

root@qemux86:~/skels/interrupts# ls
kbd.ko

După pornirea mașinii virtuale QEMU vom putea folosi comenzi în fereastra QEMU (sau în minicom) pentru a încărca și descărca modulul de kernel:

root@qemux86:~# insmod skels/<lab_name>/<task_name>/<module_name>.ko 
root@qemux86:~# rmmod skels/<lab_name>/<task_name>/<module_name>.ko 

Găsiți definițiile următoarelor simboluri în nucleul Linux:

• structura resource;
• funcția request_region și de acolo funcția __request_region;
• funcția request_irq și de acolo funcția request_threaded_irq;
• funcția inb, varianta de pe arhitectura x86.

Urmăriți în codul nucelului Linux:

• funcția de inițializare a driver-ului de tastatură i8042_setup_kbd
• funcția de tratarea a întreruperii pentru tastatură AT sau PS/2, înregistrată cu funcția de inițializare: atkbd_interrupt

Obiectivul exercițiilor următoare este să creați un driver pentru a intercepta tastele apăsate (keylogger). Driver-ul va intercepta IRQ-ul destinat controller-ului de tastatură și va inspecta codurile tastelor primite, stocându-le într-un buffer.

Pentru început ne propunem să alocăm spații din zona I/O pentru dispozitive hardware. Vom vedea că nu putem să alocăm spațiu pentru tastatură întrucât regiunea aferentă e deja alocată. Apoi vom aloca spațiu I/O pentru porturi care nu sunt folosite.

În fișierul kbd.c avem un schelet de implementare a unui driver de tastatură. Parcurgeți codul sursă din acest fișier și urmăriți funcția kbd_init. Observați că porturile de care avem nevoie sunt I8042_STATUS_REG și I8042_DATA_REG.

Urmăriți comentariile marcate cu TODO 1 pentru a înregistra porturile de I/O și asigurați-vă că ați tratat corect erorile. De asemenea, deînregistrați porturile în funcția kbd_exit.

Compilați fișierul sursă kdb.c în modulul kdb.ko folosind, pe sistemul fizic, comanda

make build

și, după ce l-ați copiat pe mașina virtuală, încărcați-l în nucleu, în mașina virtuală QEMU, folosind comanda

insmod kbd.ko

Observați că obțineți eroare la încărcare: insmod: Can't insert 'kbd.ko': Device or resource busy. Acest lucru se întâmplă întrucât avem deja un driver care a întregistrat spațiul de I/O și kernel-ul poate deja accesa porturile I/O aferente. Ca să validăm că, într-adevăr, adresele aferente celor două registre (STATUS_REG și DATA_REG) sunt înregistrate, rulăm, în mașina virtuală QEMU comanda

cat /proc/ioports | grep keyboard

Observăm că cele două porturi (0x60: DATA_REG și 0x64:STATUS_REG) corespunzătoare registrelor pentru tastatură sunt înregistrate de kernel la boot, deci nu vom putea să eliminăm modulul care le deține.

Pentru a putea testa cu succes alocarea de porturi I/O, vom păcăli kernelul prin înregistrarea porturilor 0x61 și 0x65.

Folosiți funcția request_region (în cadrul funcției kbd_init) pentru a aloca porturile aferente și folosiți funcția release_region (în cadrul funcției kbd_exit). Apoi compilați și inserați modulul în nucleu. Verificați conținutul fișierului /proc/ioports și verificați acum că cele două porturi I/O sunt alocate driverului nostru.

root@qemux86:~# insmod skels/interrupts/kbd.ko
kbd: loading out-of-tree module taints kernel.
Driver kbd loaded
root@qemux86:~# cat /proc/ioports | grep kbd
0061-0061 : kbd
0065-0065 : kbd

Descărcați modulul din kernel folosind comanda

rmmod kbd

și verificați acum conținutul fișierului /proc/ioports; observți că a dispărut alocarea spațiului I/O pentru cele două porturi.

Urmărim să înregistrăm o rutină de tratare a întreruperii de tastatură. Veți scrie o funcție (rutină) de tratare a înteruperii și o veți înregistra folosind request_irq.

Implementarea o veți face în fișierul kbd.c. Zonele din program în care trebuie să acționați au comentarii marcate cu /* TODO 2: ... */ și indicații despre ce trebuie să urmăriți.

Pentru început definiți rutina de tratare a întreruperii (numită kbd_interrupt_handle) ca nefăcând nimic. Rutina trebuie să lase întreruperea să fie procesată de handler-ul inițial; în caz contrar, veți pierde controlul tastaturii în mașina virtuală.

Apoi înregistrați și deînregistrați rutina de tratare a întreruperii. Linia de întrerupere (IRQ line) este definită de macro-ul I8042_KBD_IRQ. Rutina de tratare a întreruperii trebuie înregistrată cu IRQF_SHARED, pentru a partaja linia de întrerupere cu driverul de tastatură (i8042).

Compilați modulul și încărcați-l în nucleu. Ulterior încărcării în nucleu, puteți observa înregistrarea liniei de întrerupere prin consultarea fișierului /proc/interrupts. Urmăriți linia din output aferentă IRQ line-ului pentru tastatură (definit în macro-ul I8042_KBD_IRQ). Observați că sunt două drivere înregistrate la această linie de întreruper (deci avem o linie de întrerupere partajată): driverul inițial i8042 și driverul nostru kbd. Descărcați modulul din nucleu.

Afișați un mesaj în rutina de tratare a întreruperii pentru a verifica dacă este apelată. Compilați și reîncărcați modulul în nucleu. Verificați folosind dmesg că rutina de tratatre a întreruperii este apelată în momentul în care apăsați pe tastatură în mașina virtuală.

Pentru implementarea keylogger-ului vrem să colectăm tastele apăsate într-un buffer al cărui conținut să îl transmitem apoi în user space. Pentru aceasta în rutina de tratare a întreruperii veți face următoarele:

1. Veți captura tastele apăsate (doar pressed nu și released)/
2. Veți identifica tastele ce reprezintă caractere ASCII.
3. Veți copia caracterele ASCII corespunzătoare tastelor apăsate și le veți stoca în buffer-ul buf din structura de tip struct kbd aferentă dispozitivului.

Implementarea o veți face în fișierul kbd.c. Zonele din program în care trebuie să acționați au comentarii marcate cu /* TODO 3: ... */ și indicații despre ce trebuie să urmăriți.

La fiecare pas compilați modulul, încărcați modulul în kernel, apăsați în mașina virtuală taste pentru a verifica funcționalitatea, și apoi descărcați modulul.

Pentru început completați funcția i8042_read_data() pentru citirea registrului I8042_DATA_REG al controller-ului de tastatură. Funcția trebuie doar să returneze valoarea registrului. Valoarea registrului se mai numește scancode, este ceea ce este generat la fiecare apăsare de tastatură.

Apelați funcția i8042_read_data() în handler-ul de întrerupere kbd_interrupt_handler() (adică la fiecare tastă apăsată) și afișați valoarea citită din registru.

	pr_info("IRQ %d: scancode=0x%x (%u) pressed=%d ch=%c\n",
		irq_no, scancode, scancode, pressed, ch);

Observați că scancode-ul (valoarea registrului citit) nu este un caracter ASCII aferent tastei apăsate. Va trebui să interepretăm scancode-ul.

Observați că valoarea registrului este un cod al tastei apăsate (se mai numește scancode), nu reprezintă valoarea ASCII a caracterului apăsat. De asemenea, este trimisă o întrerupere la apăsarea tastei și este trimisă o întrerupere la eliberarea tastei. Pentru aceasta, va trebui să selectați doar cazurile de apăsare de tastă și să decodificați tastele apăsate în caractere ASCII.

showkey -s

În handler-ul de întrerupere (kbd_interrupt_handler) interpretați scancode-ul pentru a vedea dacă este o apăsare sau o ridicare de tastă și obțineți caracterul ASCII aferent. Afișați informațiile obținute.

	pr_info(LOG_LEVEL "IRQ %d: scancode=0x%x (%u) pressed=%d ch=%c\n",
		irq_no, scancode, scancode, pressed, ch);

Dorim să colectăm caracterele apăsate (nu și celelalte taste) într-un buffer circular care apoi va fi citit din user space.

Actualizați handler-ul de tratare a întreruperii (kbd_interrupt_handler) astfel încât un caracter ASCII citit să fie adăugat la sfârșitul buffer-ului aferent dispozitivului. Dacă buffer-ul este plin, caracterul cel mai vechi o sa fie suprascris.

	struct kbd *data = (struct kbd *) dev_id;

Pentru a avea acces la datele colectate de keylogger va trebui să le transmitem în user space. Facem acest lucru prin intermediului unui dispozitiv de tip caracter (/dev/kbd). La citirea din acest dispozitiv de tip caracter vom primi datele din buffer-ul din kernel space în care am colectat tastele apăsate.

Implementarea o veți face în fișierul kbd.c. Zonele din program în care trebuie să acționați au comentarii marcate cu /* TODO 4: ... */ în funcția kbd_read() și indicații despre ce trebuie să urmăriți.

La fiecare pas compilați modulul, încărcați modulul în kernel, apăsați în mașina virtuală taste pentru a verifica funcționalitatea, și apoi descărcați modulul.

Este permis un singur cititor la un moment dat astfel încât protejăm codului funcției kbd_read() cu un mutex.

Întrucât nu dorim modificări la nivelul buffer-ului din partea handler-ului de întrerupere în timp ce facem citirea sa în funcția kbd_read() veți folosiți un spinlock și veți dezactiva întreruperile în funcția kbd_read.

Completați funcția get_char pentru a obține următorul caracter care trebuie citit din buffer. Aveți grijă la implementarea buffer-ului circular (să nu citiți dincolo de dimensiunea buffer-ului și de poziția de scriere).

Pentru copierea în user space veți folosi apelul put_user pentru fiecare caracter în parte, obținut folosind funcția get_char.

Pentru testare, va trebui să creați fișierul de tip caracter /dev/kbd folosind utilitarul mknod cu majorul și minorul dispozitivului sunt definiți în macro-urile din kbd.c: KBD_MAJOR și KBD_MINOR. Adică va trebui să rulați comanda

mknod /dev/kbd c 42 0

Compilați modulul pe sistemul fizic, apoi porniți mașina virtuală și încărcați modulul în nucleul mașinii virtuale. Testați folosind comanda

cat /dev/kbd

O să obțineți conținutul bufferului keylogger-ului din kernel space.

Dorim să "curățăm" buffer-ul atunci când se scrie în device node-ul asociat driver-ului. În acel moment buffer-ul va fi resetat: conținutul său va fi resetat și dimensiunea va fi 0.

Implementarea o veți face în fișierul kbd.c. Urmăriți comentariile marcate cu TODO 5. Implementați funcția reset_buffer și adăugați operația write la kbd_fops.

Pentru testare, va trebui să creați fișierul de tip caracter /dev/kbd folosind utilitarul mknod cu majorul și minorul dispozitivului sunt definiți în macro-urile din kbd.c: KBD_MAJOR și KBD_MINOR. Adică va trebui să rulați comanda

mknod /dev/kbd c 42 0

Compilați modulul pe sistemul fizic, apoi porniți mașina virtuală și încărcați modulul în nucleul mașinii virtuale. Consultați conținutul buffer-ului folosind comanda

cat /dev/kbd

Apăsați pe taste și apoi rulați comanda echo “clear” > /dev/kbd și apoi consultați din nou conținutul buffer-ului. Ar trebui să fie resetat.

Implementați colectarea de date de la tastatură, și transmiterea lor în user space folosind API-ul kfifo.

• Soluții exerciții laborator 5