|
|
| Riga 1: |
Riga 1: |
| ==Installazione QEMU con qvm86/kqemu per Debian/Ubuntu== | | ==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 installarli: andiamo a visitare il sito [http://packages.debian.org packages.debian.org] e clicchiamo il link "Ricerca nel contenuto dei pacchetti". Nel campo "Parola chiave" inseriamo ad esempio xev e scegliamo nel menu a tendina "Distribuzione" il nostro ramo Debian. In questo modo appuriamo in quale pacchetto è contenuto il programma xev (ed in maniera analoga possiamo saperlo per xmodmap). Fatto questo possiamo procedere ad installare il pacchetto con aptitude. |
|
| |
|
| ====1. Fase Preliminare====
| |
| Assicuratevi di aver installato i pacchetti necessari a scaricare e compilare il tutto:
| |
| * '''ssh''' e '''cvs''' (per scaricare qvm86 occorre andare via cvs remoto)
| |
| * '''patch''' (per usare qvm86 con qemu occorre effettuare una piccola patch ai sorgenti di qemu)
| |
| * '''gcc-3.3''' oppure '''gcc-3.4''' (qemu non ancora compilabile col gcc 4.0)
| |
| * '''libsdl1.2-dev'''
| |
| * '''zlib1g-dev'''
| |
| * '''make'''
| |
| * '''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==== | | ==Configurazione layout tasti== |
| 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.
| |
| $ tar zxvf qemu-0.8.0.tar.gz
| |
| $ cd qemu-0.8.0
| |
|
| |
|
| ====3. Recupero file qvm86====
| | 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 <code>xev</code>, a programma lanciato premiamo il tasto che ci interessa configurare e dovremmo avere un output del genere |
| 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'''.
| |
| $ export CVS_RSH=ssh
| |
| $ export CVSROOT=:pserver:anonymous@cvs.savannah.nongnu.org:/sources/qvm86
| |
| $ cvs -z3 co qvm86
| |
|
| |
|
| ====4. Applicazione patch====
| | <pre> KeyRelease event, serial 29, synthetic NO, window 0x1c00001, |
| Applicate dalla directory dei sorgenti di qemu la patch provvista da qvm86.
| | root 0x75, subw 0x0, time 1436703, (287,442), root:(292,515), |
| $ patch -p0 < qvm86/patch.qvm86
| | state 0x0, keycode 236 (keysym 0x0, NoSymbol), same_screen YES, |
| | XLookupString gives 0 bytes: |
| | </pre> |
|
| |
|
| ====5. Configurazione====
| | da queste righe otteniamo il keycode (nell'esempio 236) e notiamo anche che non gli è associato nessun nome (<tt> ..., NoSymbol</tt>). Adesso dobbiamo associare un nome al tasto riferito da quel keycode. Quest'operazione deve essere fatta modificando il file <tt>~/.xmodmaprc</tt> che se non esiste va creato. |
| Configurate l'ambiente di compilazione avviando lo script <code>./configure</code>.
| |
| 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 questo file vanno inserite righe del tipo |
| $ make clean
| |
| $ ./configure --cc=gcc-3.3 --target-list=i386-softmmu
| |
| $ make
| |
|
| |
|
| Se non ci sono errori, ora potete diventare root ed installare qemu.
| | <pre>keycode num = nome</pre> |
| $ su
| |
| Password:
| |
| # make install
| |
|
| |
|
| 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>.
| | dove num è il keycode ottenuto con <code>xev</code> 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 <code>xmodmap ~/.xmodmaprc</code> e rilanciando <code>xev</code> dovremmo ottenere: |
|
| |
|
| ====6. Caricamento modulo====
| | <pre>KeyPress event, serial 26, synthetic NO, window 0x2400001, |
| 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.
| | 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: |
| | </pre> |
|
| |
|
| Esempio di procedura manuale (per chi '''non ha''' installato il pacchetto udev):'''
| | Abbiamo abbinato al tasto un nome (nell'esempio F13). |
| # Queste due operazioni sono da fare come root una volta sola:
| |
| # mknod /dev/qvm86 c 222 0
| |
| # chmod 666 /dev/qvm86
| |
| #
| |
| # 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):
| | ==Associazione programmi== |
| # 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):
| | 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 altrimenti con un programma che permette di associare a dei tasti o ad una combinazione di tasti una determinata azione. Di questi ultimi ne esistono vari: <code>xbindkeys</code>, <code>sven</code>, <code>lineak</code> etc. In questo tutorial useremo <code>xbindkeys</code> la cui configurazione è molto semplice. |
| * 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.
| | Anzitutto bisogna installarlo: |
|
| |
|
| 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>.
| | <pre> # apt-get install xbindkeys </pre> |
|
| |
|
| === Qemu col supporto kqemu (proprietario) ===
| | Fatto ciò bisogna modificare il file <tt>~/.xbindkeysrc</tt>, 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. 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. |
|
| |
|
| ====1. Fase Preliminare====
| | Se abbiamo Kde dobbiamo creare uno script del tipo |
| Assicuratevi di aver installato i pacchetti necessari a compilare il tutto:
| | <pre> |
| * '''gcc-3.3''' oppure '''gcc-3.4''' (qemu non � ancora compilabile col gcc 4.0)
| | #!/bin/bash |
| * '''libsdl1.2-dev'''
| | xmodmap ~/.xmodmaprc |
| * '''zlib1g-dev'''
| | xbindkeys -f ~/.xbindkeysrc |
| * '''make'''
| | </pre> |
| * '''gcc'''
| | salvarlo ad esempio come <code>mapping</code> dargli i permessi di esecuzione <code>chmod a+x mapping</code> e copiarlo in <tt>~/.kde/Autostart</tt>. |
| * '''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====
| | Se abbiamo gnome dopo aver creato lo script, dobbiamo creare da root un link allo script in <tt>/usr/bin</tt>: |
| 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.
| | <pre> |
| $ tar zxvf qemu-0.8.0.tar.gz
| | # cd /usr/bin |
| $ tar zxvf kqemu-0.7.2.tar.gz -C qemu-0.8.0
| | # ln -s path_script/mapping mapping |
| $ cd qemu-0.8.0
| | </pre> |
| | e poi da ''Desktop -> Preferenze -> Sessioni'' nella scheda ''Startup Program'' aggiungere <code>mapping</code>. |
|
| |
|
| ====3. Configurazione====
| | '''Nota''': per gli utenti gnome dopo aver modificato <tt>.xmodmaprc</tt>, rifacendo il login potrebbe apparire una schermata del tipo |
| 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>.
| | [[Immagine:loadmap.jpg|center]] |
| $ make clean
| |
| $ ./configure --cc=gcc-3.4 --target-list=i386-softmmu
| |
| $ make
| |
|
| |
|
| Se non ci sono errori, ora potete diventare root ed installare qemu.
| | se scegliamo di caricare la modmap in questo modo dallo script <code>mapping</code> dobbiamo eliminare |
| $ su
| | la riga <tt>xmodmap ~/.xmodmaprc</tt>. |
| 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>.
| | ---- |
| | | [[Utente:Itbhp|itbhp]] 11:07, 21 Apr 2006 (EDT) |
| ====4. Caricamento modulo====
| | [[Categoria:Desktop]][[Categoria:Hardware]] |
| 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]] | |
Preparazione: installazione dei programmi
Per configurare i tasti multimediali da linux servono essenzialmente due programmi: xev e xmodmap. Prima di tutto, quindi, dobbiamo installarli: andiamo a visitare il sito packages.debian.org e clicchiamo il link "Ricerca nel contenuto dei pacchetti". Nel campo "Parola chiave" inseriamo ad esempio xev e scegliamo nel menu a tendina "Distribuzione" il nostro ramo Debian. In questo modo appuriamo in quale pacchetto è contenuto il programma xev (ed in maniera analoga possiamo saperlo per xmodmap). Fatto questo possiamo procedere ad installare il pacchetto con aptitude.
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 altrimenti con un programma che permette di associare a dei tasti o ad una combinazione di tasti una determinata azione. Di questi ultimi ne esistono vari: xbindkeys, sven, lineak etc. In questo tutorial useremo xbindkeys la cui configurazione è molto semplice.
Anzitutto bisogna installarlo:
# apt-get 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.
Se abbiamo Kde dobbiamo creare uno script del tipo
#!/bin/bash
xmodmap ~/.xmodmaprc
xbindkeys -f ~/.xbindkeysrc
salvarlo ad esempio come mapping dargli i permessi di esecuzione chmod a+x mapping e copiarlo in ~/.kde/Autostart.
Se abbiamo gnome dopo aver creato lo script, dobbiamo creare da root un link allo script in /usr/bin:
# cd /usr/bin
# ln -s path_script/mapping mapping
e poi da Desktop -> Preferenze -> Sessioni nella scheda Startup Program aggiungere mapping.
Nota: per gli utenti gnome dopo aver modificato .xmodmaprc, rifacendo il login potrebbe apparire una schermata del tipo
se scegliamo di caricare la modmap in questo modo dallo script mapping dobbiamo eliminare
la riga xmodmap ~/.xmodmaprc.
itbhp 11:07, 21 Apr 2006 (EDT)
