|
|
| (10 versioni intermedie di 5 utenti non mostrate) |
| Riga 1: |
Riga 1: |
| ==Installazione QEMU con qvm86/kqemu per Debian/Ubuntu== | | {{Versioni compatibili|Jessie|Stretch|Buster}} |
| | __TOC__ |
| | ==Preparazione: installazione dei programmi== |
|
| |
|
| === Qemu con supporto qvm86 (libero, ma sperimentale) ===
| | Per configurare i tasti multimediali da Linux servono essenzialmente due programmi: '''<code>xev</code>''' e '''<code>xmodmap</code>'''. Prima di tutto, quindi, dobbiamo installare i pacchetti con [[privilegi di amministrazione]]: |
| | <pre># apt install x11-utils x11-xserver-utils</pre> |
| | il primo (<code>x11-utils</code>) conterà il programma <code>xev</code>, il secondo conterrà invece il programma <code>xmodmap</code>. |
|
| |
|
| ====1. Fase Preliminare==== | | ==Configurazione layout tasti== |
| Assicuratevi di aver installato i pacchetti necessari a scaricare e compilare il tutto:
| | Dopo aver installato questi programmi la prima cosa da fare è scoprire i keycode relativi ai tasti che ci interessano e questo verrà fatto con <code>xev</code>. Apriamo una console e scriviamo <code>xev</code>, a programma lanciato premiamo il tasto che ci interessa configurare e dovremmo avere un output del genere: |
| * '''ssh''' e '''cvs''' (per scaricare qvm86 occorre andare via cvs remoto)
| | <pre> |
| * '''patch''' (per usare qvm86 con qemu occorre effettuare una piccola patch ai sorgenti di qemu)
| | KeyRelease event, serial 29, synthetic NO, window 0x1c00001, |
| * '''gcc-3.3''' oppure '''gcc-3.4''' (qemu non � ancora compilabile col gcc 4.0)
| | root 0x75, subw 0x0, time 1436703, (287,442), root:(292,515), |
| * '''libsdl1.2-dev'''
| | state 0x0, keycode 236 (keysym 0x0, NoSymbol), same_screen YES, |
| * '''zlib1g-dev'''
| | XLookupString gives 0 bytes: |
| * '''make'''
| | </pre> |
| * '''kernel-headers-'''''versione_del_kernel_in_uso'' (oppure '''linux-headers-'''''versione_del_kernel_in_uso'' se avete una Ubuntu od usate una Debian unstable con un kernel recente). La versione pu� essere individuata eseguendo il comando <code>uname -r</code>.
| | da queste righe otteniamo il keycode (nell'esempio 236) e notiamo anche che non gli è associato nessun nome (<code> ..., NoSymbol</code>). Adesso dobbiamo associare un nome al tasto riferito da quel keycode. Quest'operazione deve essere fatta modificando il file <code>~/.xmodmaprc</code> che se non esiste va creato. |
|
| |
|
| ====2. Recupero file QEMU====
| | In questo file vanno inserite righe del tipo: |
| Scaricate da [http://fabrice.bellard.free.fr/qemu/download.html http://fabrice.bellard.free.fr/qemu/download.html] gli archivi dei codici sorgenti di QEMU, e come '''utente diverso da root''' scompattateli in una directory e poi entrateci.
| | <pre> |
| $ tar zxvf qemu-0.8.0.tar.gz
| | keycode num = nome |
| $ cd qemu-0.8.0
| | </pre> |
| | dove <code>num</code> è il keycode ottenuto con <code>xev</code> e la stringa ''nome'' dovrà essere del tipo <code>FXX</code> dove al posto di <code>XX</code> dobbiamo inserire un numero maggiore di dodici. |
|
| |
|
| ====3. Recupero file qvm86====
| | Adesso lanciando da shell <code>xmodmap ~/.xmodmaprc</code> e rilanciando <code>xev</code> dovremmo ottenere: |
| Scaricate via cvs i sorgenti di qvm86, in modo che siano all'interno della directory dei sorgenti di qemu, sempre con un utente '''diverso da root'''.
| | <pre> |
| $ export CVS_RSH=ssh
| | KeyPress event, serial 26, synthetic NO, window 0x2400001, |
| $ export CVSROOT=:pserver:anonymous@cvs.savannah.nongnu.org:/sources/qvm86
| | root 0x75, subw 0x0, time 267243, (597,651), root:(603,723), |
| $ cvs -z3 co qvm86
| | state 0x0, keycode 236 (keysym 0xffca, F13), same_screen YES, |
| | XLookupString gives 0 bytes: |
| | </pre> |
|
| |
|
| ====4. Applicazione patch====
| | Abbiamo abbinato al tasto un nome (nell'esempio F13). |
| Applicate dalla directory dei sorgenti di qemu la patch provvista da qvm86.
| |
| $ patch -p0 < qvm86/patch.qvm86
| |
|
| |
|
| ====5. Configurazione==== | | ==Associazione programmi== |
| Configurate l'ambiente di compilazione avviando lo script <code>./configure</code>.
| | Ora potremmo voler far eseguire un'azione al tasto configurato, questa cosa la si può fare in svariati modi: se si ha Gnome dal menu ''Desktop -> Preferenze -> Scorciatoie da tastiera'' associando al tasto un'azione predefinita, e abbiamo finito. Similmente per altri ambienti desktop. |
| Verificate che sia tutto ok, poi compilate il tutto ed installate.
| |
| $ ./configure --cc=gcc-3.3
| |
| $ make
| |
| Se avviando <code>./configure</code> avete errori del tipo che non si riesce a trovare la parte di sviluppo di libsdl, avete scompattato gli archivi come root. Leggete meglio sopra e ricominciate da capo.
| |
|
| |
|
| Se dopo aver avviato <code>make</code> ci sono errori di compilazione, ci si pu� limitare a compilare il solo modulo di emulazione x86, aggiungendo l'opzione <code>--target-list=i386-softmmu</code> al comando <code>./configure</code>.
| | ===In ambienti grafici minimali=== |
| $ make clean
| | Invece, se usiamo un ambiente grafico minimale, ci potrebbe servire un programma che permette di associare a dei tasti o ad una combinazione di tasti una determinata azione. Di questi ultimi ne esistono vari: in questo tutorial useremo <code>xbindkeys</code>, la cui configurazione è molto semplice. |
| $ ./configure --cc=gcc-3.3 --target-list=i386-softmmu
| |
| $ make
| |
|
| |
|
| Se non ci sono errori, ora potete diventare root ed installare qemu.
| | Anzitutto bisogna installarlo: |
| $ su
| | <pre> |
| Password:
| | # apt install xbindkeys |
| # make install
| | </pre> |
|
| |
|
| A questo punto qemu � installato in <code>/usr/local/bin/qemu</code>, ed il modulo qvm86 si trova in <code>/lib/modules/''versione_del_kernel''/misc/qvm86.ko</code>.
| | Fatto ciò bisogna modificare il file <code>~/.xbindkeysrc</code>, che è formato da righe del tipo: |
| | <pre> |
| | "comando o programma da eseguire" |
| | tasto o combinazione di tasti associata |
| | </pre> |
| | per esempio: |
| | <pre> |
| | "firefox" |
| | Control+F13 // si potevano usare anche Shift o Alt |
| | </pre> |
| | Modificato il file bisogna lanciare da shell <code>xbindkeys -f ~/.xbindkeysrc</code> e tutto dovrebbe funzionare. |
|
| |
|
| ====6. Caricamento modulo====
| | Ora però dobbiamo fare in modo che il mapping dei tasti multimediali e l'associazione del programma tramite <code>xbindkeys</code> avvenga ogni volta che facciamo il login. La procedura esatta varia a seconda dell'ambiente utilizzato. |
| Prima di eseguire qemu va caricato il modulo del kernel <code>qvm86</code>, va eventualmente creato <code>/dev/qvm86</code> (usato per interagire col kernel) e gli vanno dati permessi adeguati.
| |
|
| |
|
| Esempio di procedura manuale (per chi '''non ha''' installato il pacchetto udev):'''
| | {{Autori |
| # Queste due operazioni sono da fare come root una volta sola:
| | |Autore = [[Utente:Itbhp|itbhp]] 11:07, 21 Apr 2006 (EDT) |
| # mknod /dev/qvm86 c 222 0
| | }} |
| # chmod 666 /dev/qvm86
| | [[Categoria:Tastiere]][[Categoria:Ottimizzazione del sistema]] |
| #
| |
| # Questa operazione va eseguita come root ad ogni avvio del sistema per usare qemu
| |
| # modprobe qvm86
| |
| | |
| Esempio di procedura manuale (per chi '''ha''' installato il pacchetto udev):
| |
| # Queste due operazioni vanno eseguite come root ad ogni avvio del sistema
| |
| # modprobe qvm86
| |
| # chmod 666 /dev/qvm86
| |
| | |
| Per far eseguire '''automaticamente''' queste operazioni ad ogni avvio del sistema (consigliato):
| |
| * diventate root (<code>su -</code>)
| |
| * modificate il file <code>/etc/modules</code> aggiungendo la riga <code>qvm86</code>, in modo che il modulo venga automaticamente caricato al boot.
| |
| * create il file <code>/etc/modprobe.d/qvm86</code> contenente le seguenti righe:
| |
| ** per chi '''non ha''' installato il pacchetto udev:
| |
| install qvm86 /sbin/modprobe --ignore-install qvm86 \
| |
| && (test -c /dev/qvm86 || mknod /dev/qvm86 c 222 0) \
| |
| && chmod 666 /dev/qvm86
| |
| :* per chi '''ha''' installato il pacchetto udev:
| |
| install qvm86 /sbin/modprobe --ignore-install qvm86 && chmod 666 /dev/qvm86
| |
| | |
| Una volta caricato il modulo e dati i permessi di lettura a /dev/qvm86 siamo pronti per eseguire il nuovo qemu.
| |
| | |
| Accertatevi che il qemu che andrete ad eseguire '''sia quello compilato in <code>/usr/local/bin/qemu</code>''': potete farlo eseguendo <code>type qemu</code>.
| |
| | |
| === Qemu col supporto kqemu (proprietario) ===
| |
| | |
| ====1. Fase Preliminare====
| |
| Assicuratevi di aver installato i pacchetti necessari a compilare il tutto:
| |
| * '''gcc-3.3''' oppure '''gcc-3.4''' (qemu non � ancora compilabile col gcc 4.0)
| |
| * '''libsdl1.2-dev'''
| |
| * '''zlib1g-dev'''
| |
| * '''make'''
| |
| * '''gcc'''
| |
| * '''kernel-headers-'''''versione_del_kernel_in_uso'' (oppure '''linux-headers-'''''versione_del_kernel_in_uso'' se avete una Ubuntu od usate una Debian unstable con un kernel recente). La versione pu� essere individuata eseguendo il comando <code>uname -r</code>.
| |
| | |
| ====2. Recupero file QEMU/KQEMU====
| |
| Scaricate archivi dei codici sorgenti di [http://fabrice.bellard.free.fr/qemu/download.html QEMU e KQEMU], e come '''utente diverso da root''' scompattateli in modo che la directory di kqemu venga estratta all'interno della directory di qemu. Quindi entrate nella directory dei sorgenti.
| |
| $ tar zxvf qemu-0.8.0.tar.gz
| |
| $ tar zxvf kqemu-0.7.2.tar.gz -C qemu-0.8.0
| |
| $ cd qemu-0.8.0
| |
| | |
| ====3. Configurazione====
| |
| Configurate l'ambiente di compilazione avviando lo script <code>./configure</code>.
| |
| Verificate che sia tutto ok e che il supporto kqemu sia attivato, in modo che venga compilato
| |
| il modulo corretto per il vostro kernel. Poi compilate il tutto ed installate.
| |
| $ ./configure --cc=gcc-3.4
| |
| $ make
| |
| Se avviando <code>./configure</code> avete errori del tipo che non si riesce a trovare la parte di sviluppo di libsdl, avete scompattato gli archivi come root invece che come utente comune. Leggete meglio sopra e ricominciate da capo.
| |
| Chi utilizza Ubuntu Breezy (5.10) definisca anche la variabile di ambiente CC che punti a gcc-3.4 (<code>export CC='/usr/bin/gcc-3.4'</code>), altrimenti il linking di kqemu verra' fatto con gcc-4.0 (compilatore di default su Ubuntu Breezy 5.10) e in fase di caricamento del modulo si avra' l'errore '''Invalid module format''', poiche' il kernel standard di questa distribuzione e' compilato con gcc-3.4. La variabile va definita prima di eseguire il <code>make</code>; se cio' non e' stato fatto per tempo allora e' necessario entrare nella directory <code>kqemu/</code> ed eliminare quanto gia' compilato con <code>make clean</code>, poi ritornare nella directory principale e rilanciare <code>make</code>.
| |
| | |
| Se dopo aver avviato <code>make</code> ci sono errori di compilazione, ci si pu� limitare a compilare il solo modulo di emulazione x86, aggiungendo l'opzione <code>--target-list=i386-softmmu</code> al comando <code>./configure</code>.
| |
| $ make clean
| |
| $ ./configure --cc=gcc-3.4 --target-list=i386-softmmu
| |
| $ make
| |
| | |
| Se non ci sono errori, ora potete diventare root ed installare qemu.
| |
| $ su
| |
| Password:
| |
| # make install
| |
| | |
| A questo punto qemu � installato in <code>/usr/local/bin/qemu</code>, ed il modulo kqemu si trova in <code>/lib/modules/''versione_del_kernel''/misc/kqemu.ko</code>.
| |
| | |
| ====4. Caricamento modulo====
| |
| Prima di eseguire qemu va caricato il modulo del kernel <code>kqemu</code>, va eventualmente creato <code>/dev/kqemu</code> (usato per interagire col kernel) e gli vanno dati permessi adeguati.
| |
| | |
| Esempio di procedura manuale (per chi '''non ha''' installato il pacchetto udev):'''
| |
| # Queste due operazioni sono da fare come root una volta sola:
| |
| # mknod /dev/kqemu c 250 0
| |
| # chmod 666 /dev/kqemu
| |
| #
| |
| # Questa operazione va eseguita come root ad ogni avvio del sistema
| |
| # modprobe kqemu
| |
| | |
| Esempio di procedura manuale (per chi '''ha''' installato il pacchetto udev):
| |
| # Queste due operazioni vanno eseguite come root ad ogni avvio del sistema
| |
| # modprobe kqemu major=0
| |
| # chmod 666 /dev/kqemu
| |
| | |
| Per far eseguire '''automaticamente''' queste operazioni ad ogni avvio del sistema (consigliato):
| |
| * diventate root (<code>su -</code>)
| |
| * modificate il file <code>/etc/modules</code> aggiungendo la riga <code>kqemu</code>, in modo che il modulo venga automaticamente caricato al boot.
| |
| * create il file <code>/etc/modprobe.d/kqemu</code> contenente le seguenti righe:
| |
| ** per chi '''non ha''' installato il pacchetto udev:
| |
| install kqemu /sbin/modprobe --ignore-install kqemu \
| |
| && (test -c /dev/kqemu || mknod /dev/keqmu c 250 0) \
| |
| && chmod 666 /dev/kqemu
| |
| :* per chi '''ha''' installato il pacchetto udev:
| |
| options kqemu major=0
| |
| install kqemu /sbin/modprobe --ignore-install kqemu && chmod 666 /dev/kqemu
| |
| | |
| Una volta caricato il modulo e dati i permessi di lettura a /dev/kqemu siamo pronti per eseguire il nuovo qemu.
| |
| | |
| Accertatevi che il qemu che andrete ad eseguire '''sia quello compilato in <code>/usr/local/bin/qemu</code>''': potete farlo eseguendo <code>type qemu</code>.
| |
| | |
| == Utilizzo QEMU ==
| |
| | |
| ===Creazione immagine===
| |
| (facoltativo) Creazione di un file immagine per il disco (facoltativo)
| |
| $ qemu-img create hd.img 5G
| |
| | |
| ===Esecuzione QEMU===
| |
| ''(cambiare il boot per fare l'installazione da cd etc..)''
| |
| | |
| Per semplicita` qui avviamo qemu da root (gli utenti comuni in Debian solitamente non possono leggere direttamente /dev/cdrom), tuttavia qemu puo` tranquillamente essere eseguito come utente comune (consigliato).
| |
| # qemu -boot c -cdrom /dev/cdrom -hda /home/rob/hd.img \
| |
| -user-net -pci -m 256 -k it -localtime
| |
| | |
| Le principali opzioni di qemu sono:
| |
| | |
| * '''-m ''megabyte'' ''' --> memoria per l'emulatore = 256MB
| |
| * '''-k it''' --> tastiera italiana
| |
| * '''-localtime''' --> usa ora locale (default UTC)
| |
| * '''-pci''' --> emula scheda di rete rtl8029 PCI
| |
| * '''-boot c''' --> avvia dal dico rigido emulato (usare '''-boot d''' per il boot dal cdrom emulato)
| |
| * '''-user-net''' --> Il sistema GUEST deve essere configurato in DHCP. Qemu assegna un indirizzo dinamico "10.0.2.15" al SO guest, il quale sar� in grado di pingare solo il suo GW che � "10.0.2.2". Per testare la rete quindi avviare le applicazioni di rete, visto che il ping ''host'' non funziona.
| |
| | |
| === QEMU Networking ===
| |
| | |
| '''Sezione da revisionare per i cambiamenti nella versione 0.8.0'''
| |
| | |
| Con la soluzione indicata qui sopra, il sistema Guest riesce a navigare in Internet, ma non riesce ad accedere alle risorse del proprio host. La maniera pi� facile per configurare qemu in modo che possa fare entrambe le cose, � quella di installare vde e usare tun/tap con un bridge.
| |
| | |
| Prima di iniziare, dovete verificare che il vostro kernel supporti i seguenti moduli:
| |
| tun: "Network device support" -> "Universal TUN/TAP device driver support"
| |
| IP masquerade: "Networking options" -> "IP: Netfilter Configuration"
| |
| bridging: "Networking options" -> "802.1d Ethernet Bridging"
| |
| | |
| e dovete installare il pacchetto bridge-utils:
| |
| apt-get install bridge-utils
| |
| | |
| [http://vde.sourceforge.net Vde] sta per Virtual Distributed Ethernet ed � un programma open source che vi permette di creare un network virtuale. Noi lo utilizzeremo per far fare in modo che il sistema Guest veda se stesso come un'unit� distinta dal sistema host e possa colloquiare con questi.
| |
| | |
| Per quel che ne so io, non esiste (ancora) un pacchetto deb gi� pronto per l'uso, ma per installare vde sono sufficenti poche righe:
| |
| wget http://puzzle.dl.sourceforge.net/sourceforge/vde/vde-1.5.9.tar.gz
| |
| tar -xvzf vde-1.5.9.tar.gz
| |
| cd vde-1.5.9
| |
| ./configure
| |
| make
| |
| make install
| |
| | |
| Una volta fatto questo, siete pronti per configurare tun e il bridge:
| |
| vde_switch -tap tun0 -daemon
| |
| chmod 777 /tmp/vde.ctl
| |
|
| |
| ifconfig eth0 down
| |
| brctl addbr br0
| |
| ifconfig eth0 0.0.0.0 promisc up
| |
| ifconfig tun0 0.0.0.0 promisc up
| |
| # l'IP qui sotto � quello del computer host; modificatelo per adeguarlo alle vs esigenze
| |
| ifconfig br0 192.168.0.200 netmask 255.255.255.0 broadcast 192.168.0.255 up
| |
|
| |
| brctl stp br0 off
| |
| brctl setfd br0 1
| |
| brctl sethello br0 1
| |
| brctl addif br0 eth0
| |
| brctl addif br0 tun0
| |
| # questo invece � l'indirizzo IP del gateway
| |
| route add default gw 192.168.0.1
| |
| | |
| NB: Una volta verificato che tutto funziona, queste istruzioni vanno inserite in uno script in modo da essere eseguite automaticamente all'accensione del computer qui ne trovate uno piuttosto grezzo: [http://www.itaca.coopsoc.it/download/sources/vde_qemu vde_qemu], che va salvato in /etc/init.d. Dopodich�:
| |
| chmod u+x /etc/init.d/vde_qemu
| |
| update-rc.d -n vde_qemu defaults 90
| |
| | |
| Ora tutto � pronto per lanciare qemu, con l'ultima avvertenza che dovete usare l'apposito wrapper vdeqemu:
| |
| vdeqemu -hda disk.img -localtime -net nic -net vde
| |
| | |
| NB: con le release pi� recenti di qemu non viene pi� supportato l'argomento -tun-fd che vdeqemu utilizza nella sintassi standard. E' perci� necessario lanciare il wrapper vdeqemu con le opzioni -net nic (per attivare l'emulazione di un interfaccia di rete virtuale) e -net vde (per suggerire a vdeqemu di utilizzare la nuova sintassi di qemu)
| |
| | |
| Potete utilizzare tutte le opzioni di qemu, fuorch� -user-net, che disattiverebbe tun.
| |
| | |
| Ora il sistema guest dovrebbe accedere a tutte le porte del sistema host, in maniera totalmente trasparente: da risorse di rete dovreste vedere il vostro server samba con le sue partizioni; dal browser dovreste accedere alle pagine del vostro server web, etc. etc.
| |
| | |
| === Patch per Windows ===
| |
| | |
| Per quanto riguarda l'utilizzo della CPU, a quanto pare Windows 9x non fa un uso corretto della istruzione CPU HLT e quindi spara la cpu a 100% quando � in idle (non fa nulla) e invece la usa regolarmente quando � sotto "sforzo", paradossalmente infatti, se viene utilizzata la cpu di qemu l'utilizzo di cpu si abbassa su linux in proporzione.
| |
| | |
| La patch puo' essere scaricata [http://klingon.homelinux.net/files/amnhltm.zip qui], va installata sul Win9x GUEST.
| |
| | |
| ==Collegamenti esterni==
| |
| *[http://ubuntuforums.org/showthread.php?t=39513 http://ubuntuforums.org/showthread.php?t=39513]
| |
| *[http://fabrice.bellard.free.fr/qemu/index.html http://fabrice.bellard.free.fr/qemu/index.html]
| |
| *[http://fabrice.bellard.free.fr/qemu/qemu-doc.html http://fabrice.bellard.free.fr/qemu/qemu-doc.html]
| |
| *[http://www.debian-administration.org/?article=40 http://www.debian-administration.org/?article=40]
| |
| *[http://oui.com.br/n/content.php?article.21 http://oui.com.br/n/content.php?article.21]
| |
| *[http://www.carlsonhome.net/computer_help_log.php http://www.carlsonhome.net/computer_help_log.php]
| |
| *[http://savannah.nongnu.org/projects/qvm86/ http://savannah.nongnu.org/projects/qvm86/]
| |
| | |
| ==Conributi==
| |
| [[Utente:Themonkey|Themonkey]] 20:31, Ago 19, 2005 (EDT) The_monk_ey ( skype: the_monk_ey ) | |
| | |
| [[Utente:ianezz|ianezz]] 17:40, Nov 25, 2005 (CET) ''(per la parte di compilazione ed installazione)''
| |
| | |
| [[Utente:Paulox|Paulox]] 11:13, Dic 21, 2005 (EST) ''(aggiornamento alla versione 0.8.0 e riformattazione della pagina)''
| |
| | |
| [[Utente:Sancious|Sancious]] 23:13, Dic 13, 2006 (CET) "(aggiornamento linea di comando wrapper vdeqemu in sezione QEMU Networking)" | |
| [[Categoria:Sistema]] | |
 Versioni Compatibili
Debian 8 "jessie"
Debian 9 "stretch"
Debian 10 "buster"
|
Preparazione: installazione dei programmi
Per configurare i tasti multimediali da Linux servono essenzialmente due programmi: xev e xmodmap. Prima di tutto, quindi, dobbiamo installare i pacchetti con privilegi di amministrazione:
# apt install x11-utils x11-xserver-utils
il primo (x11-utils) conterà il programma xev, il secondo conterrà invece il programma xmodmap.
Configurazione layout tasti
Dopo aver installato questi programmi la prima cosa da fare è scoprire i keycode relativi ai tasti che ci interessano e questo verrà fatto con xev. Apriamo una console e scriviamo xev, a programma lanciato premiamo il tasto che ci interessa configurare e dovremmo avere un output del genere:
KeyRelease event, serial 29, synthetic NO, window 0x1c00001,
root 0x75, subw 0x0, time 1436703, (287,442), root:(292,515),
state 0x0, keycode 236 (keysym 0x0, NoSymbol), same_screen YES,
XLookupString gives 0 bytes:
da queste righe otteniamo il keycode (nell'esempio 236) e notiamo anche che non gli è associato nessun nome ( ..., NoSymbol). Adesso dobbiamo associare un nome al tasto riferito da quel keycode. Quest'operazione deve essere fatta modificando il file ~/.xmodmaprc che se non esiste va creato.
In questo file vanno inserite righe del tipo:
keycode num = nome
dove num è il keycode ottenuto con xev e la stringa nome dovrà essere del tipo FXX dove al posto di XX dobbiamo inserire un numero maggiore di dodici.
Adesso lanciando da shell xmodmap ~/.xmodmaprc e rilanciando xev dovremmo ottenere:
KeyPress event, serial 26, synthetic NO, window 0x2400001,
root 0x75, subw 0x0, time 267243, (597,651), root:(603,723),
state 0x0, keycode 236 (keysym 0xffca, F13), same_screen YES,
XLookupString gives 0 bytes:
Abbiamo abbinato al tasto un nome (nell'esempio F13).
Associazione programmi
Ora potremmo voler far eseguire un'azione al tasto configurato, questa cosa la si può fare in svariati modi: se si ha Gnome dal menu Desktop -> Preferenze -> Scorciatoie da tastiera associando al tasto un'azione predefinita, e abbiamo finito. Similmente per altri ambienti desktop.
In ambienti grafici minimali
Invece, se usiamo un ambiente grafico minimale, ci potrebbe servire un programma che permette di associare a dei tasti o ad una combinazione di tasti una determinata azione. Di questi ultimi ne esistono vari: in questo tutorial useremo xbindkeys, la cui configurazione è molto semplice.
Anzitutto bisogna installarlo:
# apt install xbindkeys
Fatto ciò bisogna modificare il file ~/.xbindkeysrc, che è formato da righe del tipo:
"comando o programma da eseguire"
tasto o combinazione di tasti associata
per esempio:
"firefox"
Control+F13 // si potevano usare anche Shift o Alt
Modificato il file bisogna lanciare da shell xbindkeys -f ~/.xbindkeysrc e tutto dovrebbe funzionare.
Ora però dobbiamo fare in modo che il mapping dei tasti multimediali e l'associazione del programma tramite xbindkeys avvenga ogni volta che facciamo il login. La procedura esatta varia a seconda dell'ambiente utilizzato.
Debianized 20%