Este semestre, estou cursando a disciplina de Arquitetura de Computadores II. Alguns dos trabalhos exigidos nessa disciplina são programas escritos em Assembly para arquitetura SPARC64.

Como havia uma estação Sun Ultra 1 aposentada nos armários da sala onde trabalho na faculdade, resolvi ressuscitá-la. Afinal, é bem mais legal usar um hardware real do que um emulador.

Neste artigo, conto passo-a-passo como instalei o NetBSD 4 na estação Sun Ultra 1, indicando os problemas que enfrentei e suas soluções.

Primeiramente, peço que levem em conta que eu nunca usei hardware da Sun antes, então por favor não me xinguem caso existam maneiras mais adequadas de se fazer o que eu fiz.

Baixando o CD de instalação

Antes de tudo, você vai precisar do CD de instalação do NetBSD. Eu recomendo que você baixe do diretório NetBSD-daily/netbsd-4 do ftp, pois ele já contém patches corrigindo falhas de segurança que tenham sido encontradas desde o lançamento do NetBSD.

Entre aqui, e você verá cerca de quatro diretórios, nomeados por data. Dentro de cada um deles, há um diretório iso, que contém as imagens iso para gravar em CD para cada arquitetura. A imagem destinada à arquitetura SPARC64 se chama sparc64cd.iso.

Por exemplo, eu baixei a imagem que utilizei deste link. Provavelmente esse link não vai mais funcionar quando você estiver lendo este artigo, pois eles sempre apagam os diretórios antigos, e criam diretórios mais novos. Portanto, verifique onde baixar a imagem do modo como descrevi acima.

Atenção: Se não encontrar essa imagem em algum dos diretórios, não se desespere. Tente procurar no diretório correspondente a um dia anterior. Às vezes, por algum motivo, a compilação para alguma das plataformas falha, e a imagem não aparece no diretório de alguma das datas.

Inicializando o sistema pelo CD-ROM

A primeira coisa que você nota ao ligar uma estação da Sun é o OpenFirmware. É ele que carrega o seu sistema operacional. Ele seria semelhante à BIOS de um computador de arquitetura x86 convencional, mas é claro, o OpenFirmware é bem mais completo, e inclui até mesmo uma mini-linguagem de programação.

Dependendo de como o OpenFirmware estiver configurado, ele pode parar em um prompt por alguns segundos, ou então inicializar diretamente o sistema operacional.

Para fazer com que o OpenFirmware pare e lhe forneça uma linha de comando, aperte a combinação de teclas STOP + A logo após ligar a máquina. A tecla STOP costuma ficar naquele conjunto de teclas mais à esquerda do teclado.

A linha de comando do OpenFirmware exibe a palavra ok e fica esperando por um comando. Para consultar a ajuda, como você poderia adivinhar, o comando utilizado é help.

O comando utilizado para inicializar pelo CD-ROM é o boot cdrom. Coloque o CD do NetBSD no drive e entre com esse comando. O sistema começará imediatamente a inicializar o CD de instalação.

Instalando o NetBSD

Durante a inicialização do instalador, ele vai perguntar qual o tipo de teclado que você possui. No meu caso, apenas apertei ENTER para usar a opção padrão (teclado do tipo sun), que funcionou sem problemas.

Em seguida, basta seguir as instruções da tela. Aqui eu realizei uma Full installation, usando o primeiro HD inteiro (a máquina possuía dois HDs SCSI), e criando duas partições, uma para o /, e outra para a swap.

Maiores detalhes sobre o procedimento de instalação podem ser encontrados na documentação oficial do NetBSD, mas o processo é simples e você não deverá enfrentar quaisquer problemas.

Primeiro boot

Ao final da instalação, selecione Reboot the computer. O sistema reinicializará, e o OpenFirmware passará a carregar o NetBSD imediatamente. Você já pode tirar o CD do drive.

Problemas no primeiro boot

Entretanto, enfrentei um problema logo durante a primeira inicialização. O NetBSD montava o sistema de arquivos como somente leitura, e aparecia durante o boot a seguinte mensagem:

mount_ffs: /dev/sd0a on /: specified device does not match mounted device.

A mensagem pode ser vista na foto abaixo:

Prestando mais atenção às mensagens de inicialização, principalmente às mostradas pelo dmesg, percebi as seguintes duas linhas:

 
root on sd0c dumps on sd0b
root file system type: ffs
 

Ao ler isso, percebi que era o /dev/sd0c que estava sendo montado como root inicialmente pelo kernel, e não /dev/sd0a. Não sei por qual motivo isso ocorreu, mas a solução foi simples - editar o /etc/fstab e corrigir o dispositivo.

Se este problema acontecer com você, primeiramente faça login como root para corrigi-lo. Monte o / manualmente para escrita utilizando o seguinte comando:

mount_ffs -o rw /dev/sd0c /

Agora você pode editar o /etc/fstab:

vi /etc/fstab

Aqui, eu troquei o /dev/sd0a pelo /dev/sd0c. Após as modificações, meu /etc/fstab ficou com o seguinte conteúdo:

# NetBSD /etc/fstab
# See /usr/share/examples/fstab/ for more examples.
/dev/sd0c               /       ffs     rw               1 1
/dev/sd0b               none    swap    sw               0 0
kernfs          /kern   kernfs  rw
procfs          /proc   procfs  rw,noauto

Isso resolveu completamente o problema, e no próximo boot o NetBSD já montou o sistema de arquivos para leitura e escrita.

Configurando o X

Aqui o X não se configurou automaticamente. Constava o seguinte erro nos logs do X:

SUNCG6(0): Given depth (16) is not supported by this drive

Pesquisando pela Internet, vi relatos de que isso era comum, mesmo com o Xorg e com outros sistemas operacionais. Era necessário criar um arquivo de configuração para o X especificando a profundidade de cores desejada com a opção DefaultDepth.

Segue uma cópia exata de meu /etc/X11/XF86Config, para referência:

Section "ServerLayout"
        Identifier     "XFree86 Configured"
        Screen      0  "Screen0" 0 0
        InputDevice    "Mouse0" "CorePointer"
        InputDevice    "Keyboard0" "CoreKeyboard"
EndSection
 
Section "Files"
        RgbPath      "/usr/X11R6/lib/X11/rgb"
        ModulePath   "/usr/X11R6/lib/modules"
        FontPath     "/usr/X11R6/lib/X11/fonts/misc/"
        FontPath     "/usr/X11R6/lib/X11/fonts/Speedo/"
        FontPath     "/usr/X11R6/lib/X11/fonts/Type1/"
        FontPath     "/usr/X11R6/lib/X11/fonts/CID/"
        FontPath     "/usr/X11R6/lib/X11/fonts/75dpi/"
        FontPath     "/usr/X11R6/lib/X11/fonts/100dpi/"
EndSection
Section "Module"
        Load  "extmod"
        Load  "glx"
        Load  "dbe"
        Load  "record"
        Load  "xtrap"
        Load  "type1"
        Load  "speedo"
EndSection
Section "InputDevice"
        Identifier  "Keyboard0"
        Driver      "kbd"
        Option      "Protocol" "wskbd"
        Option      "Device" "/dev/wskbd"
EndSection
 
Section "InputDevice"
        Identifier  "Mouse0"
        Driver      "mouse"
        Option      "Protocol" "wsmouse"
        Option      "Device" "/dev/wsmouse"
EndSection
 
Section "Monitor"
        Identifier   "Monitor0"
        VendorName   "Monitor Vendor"
        ModelName    "Monitor Model"
        HorizSync    29-85
        VertRefresh  50-150
        Option       "DPMS"
EndSection
 
Section "Device"
        ### Available Driver options are:-
        ### Values: <i>: integer, <f>: float, <bool>: "True"/"False",
        ### <string>: "String", <freq>: "<f> Hz/kHz/MHz"
        ### [arg]: arg optional
        #Option     "SWcursor"                  # [<bool>]
        #Option     "HWcursor"                  # [<bool>]
        #Option     "NoAccel"                   # [<bool>]
        Identifier  "Card0"
        Driver      "suncg6"
        BusID       "SBUS:fb0"
        Option      "UseFBDev"  "True"
EndSection
 
Section "Screen"
        Identifier "Screen0"
        Device     "Card0"
        Monitor    "Monitor0"
        DefaultDepth   8
        SubSection "Display"
                Viewport   0 0
                Depth     1
                Modes     "1024x768"  "800x600"  "640x480"
        EndSubSection
        SubSection "Display"
                Viewport   0 0
                Depth     4
                Modes     "1024x768"  "800x600"  "640x480"
        EndSubSection
        SubSection "Display"
                Viewport   0 0
                Depth     8
                Modes     "1024x768"  "800x600"  "640x480"
        EndSubSection
        SubSection "Display"
                Viewport   0 0
                Depth     15
                Modes     "1024x768"  "800x600"  "640x480"
        EndSubSection
        SubSection "Display"
                Viewport   0 0
                Depth     16
                Modes     "1024x768"  "800x600"  "640x480"
        EndSubSection
        SubSection "Display"
                Viewport   0 0
                Depth     24
                Modes     "1024x768"  "800x600"  "640x480"
        EndSubSection
EndSection
 

Conclusão

A Sun Ultra 1 é uma máquina muito interessante. Se você tem uma dessas encostada, realmente vale a pena colocá-la para funcionar. As últimas versões do NetBSD rodam muito bem nela.

Mais fotos

Procurando pelo ID 04b4:fef3 do dispositivo no Google, encontrei um driver escrito pelo usuário migg de um fórum.

Entretanto, esse driver não tratava corretamente os botões do Hand Pad, exigia configuração manual no código e só rodava em Linux. Então reescrevi o driver com diversas melhorias - suporte aos botões do handpad, procedimento de calibração e suporte a NetBSD, OpenBSD e FreeBSD.

Segue o código do driver, que na verdade é um programa que deve ser deixado rodando para receber os eventos do Hand Pad e repassá-los ao X.

 
/* Chinese USB Hand Pad (PenPower Touchpad) Driver
 *   for NetBSD, OpenBSD, FreeBSD and Linux.
 *
 * This driver was tested with the 7th generation handpad (04b4:fef3).
 *
 * To compile, call:
 *
 *   gcc -O2 -o handpadd handpadd.c -lX11 -lXtst -I/usr/X11R6/include \
 *      -L/usr/X11R6/lib -R/usr/X11R6/lib
 *
 * Then call it to calibrate your handpad:
 *
 *   ./handpadd -c
 *
 * Follow the instructions. It will output the command line options
 * you should use to call handpadd to get the correct calibration.
 *
 * Run handpadd with the given command line options every time you
 * want to use your handpad as a mouse in X11.
 */
 
/*-
 * Copyright (c) 2008 Paulo Matias
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */
 
/* Thanks for migg from linuxquestions.org for writing an earlier
 * driver, from which I got some ideas.
 * http://www.linuxquestions.org/questions/showthread.php?p=3145964
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stddef.h>
#include <assert.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
 
#include <X11/extensions/XTest.h>
 
#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
#	define BSD
#else
#	if defined(__linux__)
#		define LINUX
#	else
#		error "Your operating system is not supported."
#	endif
#endif
 
typedef struct {
	uint16_t pos_x;
	uint16_t pos_y;
	int btn_right;
	int btn_left;
	int btn_middle;
	int pen_on;
} packet_t;
 
#if defined(BSD)
static int read_pkt(int fd, packet_t *pkt) {
	uint8_t buf[5];
	uint8_t flags;
 
	if(read(fd, buf, sizeof(buf)) < 0)
		return 0;
 
	pkt->pos_x = buf[0] | (buf[1] << 8);
	pkt->pos_y = buf[2] | (buf[3] << 8);
 
	flags = buf[4];
 
	pkt->btn_right  = (flags & (1 << 0)) > 0;
	pkt->btn_left   = (flags & (1 << 1)) > 0;
	pkt->btn_middle = (flags & (1 << 2)) > 0;
	pkt->pen_on     = (flags & (1 << 3)) > 0;
 
	return 1;
}
#endif
 
#if defined(LINUX)
static int read_pkt(int fd, packet_t *pkt) {
	uint32_t buf[12];
	ssize_t sz;
 
	while((sz = read(fd, buf, sizeof(buf))) != sizeof(buf)) {
		if(sz == -1) {
			return 0;
		}
	}
 
	pkt->pos_x = buf[1];
	pkt->pos_y = buf[3];
 
	pkt->btn_right  = buf[ 5] > 0;
	pkt->btn_left   = buf[ 7] > 0;
	pkt->btn_middle = buf[ 9] > 0;
	pkt->pen_on     = buf[11] > 0;
 
	return 1;
}
#endif
 
static int parse_geometry(char *geom, uint16_t *x, uint16_t *y, uint16_t *w, uint16_t *h) {
	char *s;
	if((s = strtok(geom, "x")) == NULL)
		return 0;
	*x = atoi(s);
	if((s = strtok(NULL, "+")) == NULL)
		return 0;
	*y = atoi(s);
	if((s = strtok(NULL, "+")) == NULL)
		return 0;
	if((*w = atoi(s)) == 0)
		return 0;
	if((s = strtok(NULL, "")) == NULL)
		return 0;
	if((*h = atoi(s)) == 0)
		return 0;
	return 1;
}
 
static void usage(const char *cmd) {
	fprintf(stderr, "usage: %s [-c] [-g XxY+W+H] [-d /dev/uhidN]\n", cmd);
	fprintf(stderr, "       -c  Execute tablet calibration procedure.\n");
	fprintf(stderr, "       -g  Set tablet geometry setting.\n");
	fprintf(stderr, "       -d  Set device path.\n");
	exit(1);
}
 
static void calibration(int fd, uint16_t *x, uint16_t *y, uint16_t *w, uint16_t *h) {
	int evt_count;
	packet_t pkt;
 
	*x = *y = 0;
	*w = *h = 0xffff;
 
	fprintf(stderr, "** Calibration\n");
 
	evt_count = 15;
	fprintf(stderr, "-> Please tap the top left corner\n");
	while(--evt_count && read_pkt(fd, &pkt)) {
		if(!pkt.pen_on)
			continue;
		if((pkt.pos_x < *x) || (*x == 0))
			*x = pkt.pos_x;
		if((pkt.pos_y < *y) || (*y == 0))
			*y = pkt.pos_y;
	}
 
        evt_count = 15;
        fprintf(stderr, "-> Please tap the bottom right corner\n");
        while(--evt_count && read_pkt(fd, &pkt)) {
		if(!pkt.pen_on)
			continue;
                if((pkt.pos_x > *w) || (*w == 0xffff))
                        *w = pkt.pos_x;
                if((pkt.pos_y > *h) || (*h == 0xffff))
                        *h = pkt.pos_y;
        }
 
	*w -= *x;
	*h -= *y;
 
	fprintf(stderr, "** Calibration complete\n");
}
 
int main(int argc, char **argv) {
	Display *dpy;
 
	int fd;
	packet_t pkt;
 
	int	state_left   = 0,
		state_middle = 0,
		state_right  = 0;
 
	int screen_width, screen_height;
	uint16_t pad_x = 216, pad_y = 272, pad_w = 966, pad_h = 1052;
 
	int do_calibration = 0;
 
#if defined(BSD)
	char *dev_name = "/dev/uhid0";
#endif
#if defined(LINUX)
	char *dev_name = "/dev/usb/hiddev0";
#endif
 
	{
		extern char *optarg;
		char ch;
 
		while((ch = getopt(argc, argv, "cg:d:")) != -1) {
			switch(ch) {
			case 'c':
				do_calibration = 1;
				break;
			case 'g':
				if(!parse_geometry(optarg, &pad_x, &pad_y, &pad_w, &pad_h)) {
					fprintf(stderr, "invalid geometry string.\n");
					usage(argv[0]);
				}
				break;
			case 'd':
				dev_name = optarg;
				break;
			default:
				usage(argv[0]);
			}
		}
	}
 
	assert((dpy = XOpenDisplay(NULL)) != NULL);
	assert((fd = open(dev_name, O_RDONLY)) >= 0);
 
	{
		int screen = DefaultScreen(dpy);
		screen_width  = XDisplayWidth (dpy, screen);
		screen_height = XDisplayHeight(dpy, screen);
#if defined(DEBUG)
		printf("screen dimensions: %dx%d\n", screen_width, screen_height);
#endif
	}
 
	if(do_calibration) {
		calibration(fd, &pad_x, &pad_y, &pad_w, &pad_h);
		fprintf(stderr, "\nFrom now on, call %s as follows:\n", argv[0]);
		printf("   %s -g '%dx%d+%d+%d'\n\n", argv[0], pad_x, pad_y, pad_w, pad_h);
	}
 
	while(read_pkt(fd, &pkt)) {
#if defined(DEBUG)
		printf("x=%5u, y=%5u, l=%d, m=%d, r=%d, p=%d\n",
			pkt.pos_x, pkt.pos_y,
			pkt.btn_left, pkt.btn_middle, pkt.btn_right,
			pkt.pen_on);
#endif
 
		if(pkt.pen_on) {
			XTestFakeMotionEvent(dpy, -1,
				(pkt.pos_x - pad_x)*screen_width /pad_w,
				(pkt.pos_y - pad_y)*screen_height/pad_h,
				CurrentTime);
		}	
 
		if(state_left != pkt.btn_left) {
			XTestFakeButtonEvent(dpy, 1,
				(state_left = pkt.btn_left),
				CurrentTime);
		}
 
                if(state_middle != pkt.btn_middle) {
                        XTestFakeButtonEvent(dpy, 2,
                                (state_middle = pkt.btn_middle),
                                CurrentTime);
                }
 
                if(state_right != pkt.btn_right) {
                        XTestFakeButtonEvent(dpy, 3,
                                (state_right = pkt.btn_right),
                                CurrentTime);
                }
 
		XFlush(dpy);
 
	}
 
	close(fd);
 
	return 0;
}
 

O código acima também pode ser baixado aqui.

O programa deve ser compilado com:

gcc -O2 -o handpadd handpadd.c -lX11 -lXtst -I/usr/X11R6/include -L/usr/X11R6/lib -R/usr/X11R6/lib

Em seguida, rode com a opção -c para calibrar o seu handpad:

./handpadd -c

Aperte com a caneta nos cantos superior esquerdo e inferior direito do handpad quando requerido pelo programa. Feito isso, será exibida uma mensagem informando a forma como o handpadd deve ser executado toda vez para manter a calibração, utilizando a opção -g.

O handpadd deve ser deixado executando toda vez que você quiser usar o handpad como mouse no X11.

NOTA: Se você usa o FreeBSD, será necessário aplicar o seguinte patch no kernel, para que o módulo ums não tente se anexar, sem sucesso, ao dispositivo. Aplicando o patch a seguir, o dispositivo será anexado corretamente ao módulo uhid.

Note que no NetBSD e no OpenBSD não é necessário nenhum tipo de patch.

diff -Naur sys/dev/usb/ums.c.orig sys/dev/usb/ums.c
--- sys/dev/usb/ums.c.orig	2008-08-06 11:39:38.000000000 -0300
+++ sys/dev/usb/ums.c	2008-08-06 11:48:47.000000000 -0300
@@ -192,6 +192,8 @@
 	id = usbd_get_interface_descriptor(uaa->iface);
 	if (!id || id->bInterfaceClass != UICLASS_HID)
 		return (UMATCH_NONE);
+	if (usbd_get_quirks(uaa->device)->uq_flags & UQ_UMS_IGNORE)
+		return (UMATCH_NONE);
 
 	err = usbd_read_report_desc(uaa->iface, &desc, &size, M_TEMP);
 	if (err)
diff -Naur sys/dev/usb/usb_quirks.c.orig sys/dev/usb/usb_quirks.c
--- sys/dev/usb/usb_quirks.c.orig	2008-08-06 11:39:38.000000000 -0300
+++ sys/dev/usb/usb_quirks.c	2008-08-06 11:47:42.000000000 -0300
@@ -112,6 +112,11 @@
 	ANY, { UQ_KBD_IGNORE }},
  { USB_VENDOR_METAGEEK, USB_PRODUCT_METAGEEK_WISPY24X,
 	ANY, { UQ_KBD_IGNORE }},
+
+ /* Devices which should be ignored by ums */
+ { USB_VENDOR_CYPRESS, USB_PRODUCT_CYPRESS_PENPOWER_TOUCH,
+	ANY, { UQ_UMS_IGNORE }},
+
  { 0, 0, 0, { 0 } }
 };
 
diff -Naur sys/dev/usb/usb_quirks.h.orig sys/dev/usb/usb_quirks.h
--- sys/dev/usb/usb_quirks.h.orig	2008-08-06 11:39:38.000000000 -0300
+++ sys/dev/usb/usb_quirks.h	2008-08-06 11:42:59.000000000 -0300
@@ -57,6 +57,7 @@
 #define UQ_KBD_IGNORE	0x00018000 /* device should be ignored by both kbd and hid class */
 #define	UQ_MS_BAD_CLASS 0x00020000 /* doesn't identify properly */
 #define	UQ_MS_LEADING_BYTE 0x40000 /* mouse sends an unknown leading byte. */
+#define UQ_UMS_IGNORE	0x00080000 /* device should be ignored by mouse class */
 };
 
 extern const struct usbd_quirks usbd_no_quirk;
diff -Naur sys/dev/usb/usbdevs.orig sys/dev/usb/usbdevs
--- sys/dev/usb/usbdevs.orig	2008-08-06 11:39:38.000000000 -0300
+++ sys/dev/usb/usbdevs	2008-08-06 11:47:19.000000000 -0300
@@ -1067,6 +1067,7 @@
 product CYPRESS FMRADIO		0x1002	FM Radio
 product CYPRESS USBRS232	0x5500	USB-RS232 Interface
 product CYPRESS SLIM_HUB	0x6560	Slim Hub
+product CYPRESS PENPOWER_TOUCH	0xfef3  PenPower Touchpad
 
 /* Daisy Technology products */
 product DAISY DMC		0x6901	USB MultiMedia Reader
 

O patch acima também pode ser baixado aqui.

O Ion3 é um ambiente gráfico com gerenciamento de janelas em tiling. Para quem não conhece, isso significa que ele possui suporte a tiles, que são áreas nas quais podem ser "encaixadas" janelas, de forma que ocupem todo o espaço daquela área.

O Ion3 permite que você divida sua tela em quantas áreas quiser, com a posição e o tamanho que desejar. Sempre que uma área receber mais de uma janela, o Ion3 cria abas (tabs) para as outras janelas. É como se a sua tela tivesse diversas barras de tarefas, que você pode organizar como desejar. Você sempre pode arrastar uma aba (tab) de uma área (tile) para outra, da maneira que preferir.

O Ion3 também permite que você faça janelas flutuarem, ou seja, ficarem por cima sem "encaixar" em nenhuma das áreas. É possível ter também alguns workspaces sem nenhuma área, apenas com janelas flutuantes (floats).

O Ion3 é altamente configurável utilizando a linguagem de script Lua, que é leve, muito fácil de usar e poderosa. O Ion3 já vem com diversos atalhos de teclado para tarefas úteis, como abrir aplicações ou sessões ssh com suporte a tab-completion. O Ion3 é, também, bastante leve, consumindo de 2MB a 4MB de RAM.

Bom, agora que vocês já conhecem as características principais do Ion3, vamos à instalação e configuração do mesmo.

Instalação

Serei bastante breve nesta seção. Verifique se sua distribuição possui um pacote para o Ion3. Verifique também se esse pacote corresponde a uma versão atual, pois praticamente todo mês há novas versões do Ion3.

Os pacotes do Ion3 para o Arch Linux e para o NetBSD são mantidos por mim. O pacote para o Arch pode ser encontrado com o nome ion-3 no AUR. O pacote para o NetBSD pode ser encontrado com o nome ion3 no pkgsrc-wip.

Caso sua distribuição não possua pacotes para o Ion3, basta baixar o código fonte no site do autor. Certifique-se primeiramente de que você tem o interpretador Lua instalado, descompacte o código fonte do Ion3, edite o arquivo system.mk, e em seguida efetue um make && make install.

Instalando o Trayion

Eu recomendo, também, a instalação de um aplicativo externo, desenvolvido por mim, chamado Trayion. O Trayion é uma área de notificação que se integra à barra de status do Ion3.

O Ion3, por padrão, suporta apenas dockapps do Window Maker e tray icons usando o protocolo antigo do KDE. Os tray icons utilizados pelas aplicações mais novas, que seguem o padrão FreeDesktop, não são suportados, pois o autor do Ion3 considera o padrão (desnecessariamente) complicado demais para ser implementado diretamente no Ion3.

Se você usa o Arch Linux, instale o Trayion por meio de seu pacote no AUR. Se você usa o NetBSD, instale-o por meio de seu pacote no pkgsrc-wip. Caso contrário, faça o download do Trayion, descompacte, e execute um make && make install.

Iniciando o Ion3

Para iniciar o Ion3 pela primeira vez, você deve configurar para que o startx ou o seu gerenciador de login iniciem o mesmo. Para isso, basta criar um arquivo ~/.xsession contendo os comandos a serem executados quando o X for levantado. O meu ~/.xsession contém o seguinte:

#!/bin/sh
xrdb ~/.Xresources
display -window root ~/.ion3/wallpaper.jpg
(trayion&)
exec ion3

Esse código já carrega um arquivo ~/.Xresources, que pode ser utilizado para configurar certos programas, como o urxvt. Em seguida, ele busca um papel de parede em ~/.ion3/wallpaper.jpg, carrega o Trayion, e inicia o Ion3.

Para utilizar o comando display, necessário para carregar o papel de parede, você precisa do ImageMagick. No Arch Linux, o nome do pacote é imagemagick. No NetBSD, o nome é ImageMagick.

Note que o startx procura o script de inicialização acima em ~/.xinitrc, portanto é conveniente realizar o seguinte link simbólico:

$ ln -s ~/.xsession ~/.xinitrc

Agora você está pronto para iniciar o Ion3 pela primeira vez. Reinicie o X.

Primeira vez dentro do Ion3

É importante lembrar alguns atalhos de teclado padrão essenciais do Ion3. A tecla F2, por padrão, abre um terminal. A tecla F3, por padrão, abre uma pequena caixinha onde você pode digitar um comando qualquer, com suporte a tab-completion.

Se você instalou o Trayion, vai notar que a barra de status está "gorda demais". Isso ocorre por causa de uma configuração que vem por padrão no Ion3 para acomodar dockapps de Window Maker, que possuem tamanho de 64x64 pixels. O Trayion se comporta como uma dockapp, e portanto é afetado por essa configuração. Entretanto, não se preocupe, pois já vamos modificar essas configurações logo em seguida.

Modificando as configurações padrão do Ion3

Ao longo de diversos meses de uso, modifiquei muito pouco as configurações padrão do Ion3. Descreverei aqui quais configurações eu modifiquei, e como realizar essas modificações.

As configurações do Ion3 ficam geralmente em /etc/ion3. Se você instalou pelo pkgsrc no NetBSD, elas estarão em /usr/pkg/etc/ion3. Se você instalou compilando manualmente o código fonte e não modificou o local de instalação no system.mk, elas estarão em /usr/local/etc/ion3.

Cada arquivo de configuração é um script em linguagem Lua. Eu sugiro fortemente que você não modifique as configurações diretamente nos diretórios /etc/ion3, pois elas poderão ser sobrescritas durante uma atualização do Ion3.

Sempre que for modificar um arquivo de configuração, copie-o para ~/.ion3 e modifique-o no ~/.ion3. O Ion3 sempre vai buscar os arquivos de configuração primeiro em ~/.ion3, e somente depois no /etc/ion3.

Para ter uma configuração semelhante à minha, você deve copiar os seguintes arquivos:

$ cd /etc/ion3
$ cp cfg_kludges.lua cfg_ion.lua \
     cfg_ioncore.lua cfg_statusbar.lua ~/.ion3

Explico as configurações que realizei a seguir, da mais importante para a menos importante.

Modificações no cfg_kludges.lua

Se você estiver utilizando o Trayion, essa modificação é crucial, caso contrário sua barra de status ficará "gorda", ocupando espaço desnecessário da tela, além de ficar horrorosa.

Procure as seguintes linhas no arquivo ~/.ion3/cfg_kludges.lua:

defwinprop{
    is_dockapp = true,
    statusbar = "systray",
    max_size = { w = 64, h = 64},
    min_size = { w = 64, h = 64},
}

E transforme em comentários as linhas que definem o max_size e o min_size. Para fazer isso, basta colocar -- na frente das linhas. Dessa forma, o trecho acima ficará assim:

defwinprop{
    is_dockapp = true,
    statusbar = "systray",
    --max_size = { w = 64, h = 64},
    --min_size = { w = 64, h = 64},
}

Isso desabilitará a configuração que acomoda todas as dockapps por padrão em uma área de 64x64 pixels, que seria adequada para dockapps padrão do Window Maker. Desabilitando essa configuração, você permite que o Trayion possa ajustar suas próprias dimensões, escolhendo o tamanho mais adequado para si mesmo.

Modificações no cfg_ion.lua

O Ion3 usa o xterm como terminal por padrão. Nada mais justo, afinal o xterm é encontrado em praticamente qualquer instalação padrão de X.

Entretanto, eu prefiro o urxvt, que vem no pacote rxvt-unicode (o nome do pacote é o mesmo tanto no Arch Linux quanto no NetBSD).

Para modificar o terminal que é aberto ao pressionar a tecla F2 no Ion3, edite o arquivo ~/.ion3/cfg_ion.lua. Procure pela seguinte linha:

--XTERM="xterm"

Remova o -- para desmarcar como comentário, e modifique para o comando que inicia o terminal de sua preferência, por exemplo:

XTERM="urxvt"

Modificações no cfg_ioncore.lua

O Ion3 define, por padrão, atalhos de teclado para as teclas F5 e F6, respectivamente para editar e para abrir um arquivo para visualização. Por padrão, esse atalhos utilizam o run-mailcap para determinar qual programa deverá editar ou abrir um certo arquivo.

Como eu uso o gerenciador de arquivos Rox, que vem no pacote rox (mesmo nome de pacote tanto no Arch Linux como no NetBSD), e gosto do editor de textos gvim, eu preferi modificar essas configurações para utilizar o gvim para edição de arquivos, e para utilizar o rox para determinar qual programa deve abrir um certo arquivo.

Para realizar essa modificação, procure pelas seguintes linhas no arquivo ~/.ion3/cfg_ioncore.lua:

bdoc("Query for file to edit."),
kpress(ALTMETA.."F5",
       "mod_query.query_editfile(_, 'run-mailcap --action=edit')"),
 
bdoc("Query for file to view."),
kpress(ALTMETA.."F6",
       "mod_query.query_runfile(_, 'run-mailcap --action=view')"),

E modifique os comandos utilizados, fazendo com que esse trecho fique como a seguir.

bdoc("Query for file to edit."),
kpress(ALTMETA.."F5",
       "mod_query.query_editfile(_, 'gvim')"),
 
bdoc("Query for file to view."),
kpress(ALTMETA.."F6",
       "mod_query.query_runfile(_, 'rox')"),

Modificações no cfg_statusbar.lua

Por fim, você pode modificar este arquivo se desejar que informações adicionais sejam exibidas na barra de status. No meu caso, incluí informações sobre velocidade atual e temperatura do processador, e carga da bateria. Por enquanto, experimentei essa modificação apenas no Linux (não a experimentei ainda no NetBSD).

Se você possui um laptop e deseja exibir essas informações na barra de status, faça o download do arquivo statusd_laptopstatus.lua, copiando-o para ~/.ion3. É esse arquivo que implementa a consulta das informações a respeito da CPU e da bateria.

Em seguida, edite o ~/.ion3/cfg_statusbar.lua para indicar em qual local da barra de status você quer que essas informações apareçam. Procure pela linha a seguir:

template="[ %date || load: %load ] %filler%systray",

E modifique-a pela seguinte linha:

template="[ %date || load: %load ||
CPU: %laptopstatus_cpuspeed %laptopstatus_temperature ||
BATT: %laptopstatus_batterypercent %laptopstatus_batterytimeleft
] %filler%systray",

Carregando as modificações dos arquivos de configuração

Sempre que você modificar algum arquivo de configuração do Ion3, você pode recarregar as configurações sem fechar os aplicativos que estão rodando, utilizando a tecla F12 e chamando a opção session/restart no menu que se abre.

Lembre-se que todos os menus do Ion3 suportam navegação tanto por meio da digitação de parte do nome da opção seguida da tecla Tab (tab-completion) quanto por meio das setas do teclado (histórico). Para ativar a opção selecionada, basta teclar Enter.

Mudando o tema do Ion3

Várias pessoas contribuíram com diversos temas para as bordas e barras de título do Ion3. Esses temas estão disponíveis no site da coleção de scripts para o Ion3. São os scripts cujo nome começa com look.

O tema que utilizo atualmente em minha máquina é o look_atme.lua. Faça download dos temas que deseja experimentar, copiando-os, como sempre, para ~/.ion3.

Para atualizar a lista de temas, realize o mesmo procedimento descrito anteriormente para recarregar as configurações do Ion3, ou seja, tecla F12, opção session/restart.

Para trocar de tema, utilize a tecla F12 e chame a opção styles/look_nomedotema no menu que se abrirá.

Atalhos de teclado mais usados com o Ion3

Você sempre pode consultar os atalhos de teclado pressionando F1 e pressionando Enter. Isso abrirá a manpage do Ion3 em um terminal para você. Lá existe a lista de todas as teclas de atalho padrão.

As que eu mais utilizo, tirando F2 e F3, que eu já citei, são:

• Alt+S: Divide um tile em dois, um em cima e um embaixo.
• Alt+K S: Divide um tile em dois, um à esquerda, outro à direita.
• Alt+K número: Alterna entre tabs usando o teclado.
• Alt+F9: Cria um novo workspace diretamente, sem burocracia. Existe também o F9, que permite dar um nome ao workspace que está sendo criado e outras opções mais avançadas.
• Alt+número: Alterna entre workspaces.
• Alt+T com foco em uma janela, depois Alt+K A com foco em outro tile: Transfere uma janela para outro tile usando o teclado. Esse atalho de teclado é especialmente útil para transferir uma janela de um workspace para outro, caso no qual não é possível realizar a transferência simplesmente arrastando a barra de título da janela.

Note que muitas das operações podem ser realizadas com o mouse, clicando com o botão direito na barra de título da janela e escolhendo uma opção no menu, ou arrastando a barra de título da janela. Portanto, não se preocupe em ficar decorando atalhos de teclado. Você vai se acostumar com eles com o tempo, pois muitos deles são realmente práticos e úteis.

É importante lembrar que para redimensionar um tile, basta clicar sobre qualquer ponto do tile e arrastar com a tecla Alt pressionada.

Uma tecla que você talvez utilize pouco, mas que é muito interessante, é a tecla F4. Ela abre uma sessão ssh, mas tem um diferencial interessante. Ela autocompleta qualquer host ao qual você já tenha se conectado utilizando tab-completion.

Se ao pressionar F4 aparecer somente um monte de números na lista de sugestões de autocompletamento, significa que você tem a seguinte opção no seu /etc/ssh/ssh_config:

HashKnownHosts yes

Essa opção vem por padrão no Arch Linux, por exemplo. Se quiser usar o recurso de autocompletar ssh do Ion3, desabilite a linha acima transformando a mesma em um comentário:

#HashKnownHosts yes

Macetes interessantes do Ion3

Existe um macete que eu raramente preciso usar, mas que é tão interessante que vale a pena comentar aqui.

Se você perder uma janela de vista, é possível encontrá-la imediatamente no Ion3, mesmo que ela esteja em outro workspace.

Digamos que você esteja procurando pela janela do Opera. Você não sabe onde ela está, mas sabe que o título dela contém o texto "opera". Digite Alt+K K opera Enter. O Ion3 te levará imediatamente ao workspace e à janela do Opera.

Note que apenas um pedaço do texto da barra de título é necessário, e que esse pedaço de texto pode estar em qualquer parte da barra de título!

Configurando outros programas do desktop

Passarei brevemente outras configurações relevantes para o desktop, mas que não são diretamente relacionadas ao Ion3. As dicas a seguir se aplicariam mesmo que você estivesse utilizando outro gerenciador de janelas.

A primeira é para deixar o urxvt transparente e com a fonte DejaVu. A fonte DejaVu pode ser encontrada no pacote ttf-dejavu no Arch Linux, e no pacote dejavu-ttf no NetBSD. A configuração é realizada no arquivo ~/.Xresources:

URxvt*scrollBar: 0
URxvt*toolBar: 0
URxvt*font: xft:DejaVu Sans Mono:pixelsize=10
URxvt*transparent: True
URxvt*shading: 40
URxvt*tintColor: #000000
URxvt*background: #000000
URxvt*foreground: #fafffa

Outra configuração que realizei aqui foi criar um arquivo ~/.fonts.conf, como a seguir, para forçar antialising nas fontes do Qt3.

<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
<fontconfig>
 <match target="font" >
  <edit mode="assign" name="antialias" >
   <bool>true</bool>
  </edit>
 </match>
</fontconfig>

Outra configuração que necessita ser realizada por meio de arquivo de configuração (a menos que você instale o KDE) é a configuração das fontes nos aplicativos que usem a kdelibs3. Para realizar essa configuração, crie um arquivo ~/.kderc contendo as fontes desejadas, como a seguir:

[General]
StandardFont=Liberation Sans,8,-1,5,50,0,0,0,0,0
activeFont=Liberation Sans,8,-1,5,75,0,0,0,0,0
background=239,239,239
fixed=DejaVu Sans Mono,8,-1,5,50,0,0,0,0,0
font=Liberation Sans,8,-1,5,50,0,0,0,0,0
menuFont=Liberation Sans,8,-1,5,50,0,0,0,0,0
selectBackground=103,141,178
selectForeground=255,255,255
taskbarFont=Liberation Sans,8,-1,5,50,0,0,0,0,0
toolBarFont=Liberation Sans,8,-1,5,50,0,0,0,0,0
windowBackground=255,255,255
windowForeground=0,0,0

O restante das configurações pode ser realizado por meio de aplicativos gráficos.

O tema da Qt pode ser modificado por meio do aplicativo qtconfig, que acompanha a própria biblioteca Qt. Note que existe um qtconfig diferente para cada versão da Qt - um para a Qt4 e outro para a Qt3. No Arch Linux, eles ficam em /usr/bin/qtconfig e /opt/qt/bin/qtconfig, respectivamente. No NetBSD, ficam em /usr/pkg/qt4/bin/qtconfig e /usr/pkg/qt3/bin/qtconfig, respectivamente.

O tema do Gtk pode ser modificado utilizando o aplicativo gtk-chtheme, que vem no pacote gtk-chtheme do Arch, ou gtk2-chtheme do NetBSD.

Automatizando conexão em redes e montagem de dispositivos

Se você utiliza o Arch Linux, recomendo que instale o archassistant. Trata-se de um aplicativo muito interessante que colocará um tray icon no seu Trayion, e que permite que você selecione perfis de rede para conectar-se com um único clique.

O archassistant funciona com o auxílio do netcfg do Arch Linux. Maiores informações podem ser encontradas no artigo Network Profiles, da ArchWiki.

Outra tarefa bastante desejável de se automatizar é a montagem de dispositivos, principalmente pendrives e CDs. Em outros ambientes gráficos, isso costuma ser feito pelo próprio ambiente. Entretanto, é muito mais interessante utilizar o recurso autofs4 do próprio kernel Linux para realizar essa tarefa. Isso permite que a montagem automatica ocorra até mesmo nos programas do console, e permite também a desmontagem automatica dos dispositivos.

Existe um tutorial para a configuração do autofs4 no artigo AutoFS HowTo da ArchWiki.

Conclusão

O Ion3 fornece um desktop leve, confortável, moderno, versátil, ágil e configurável.

Após realizadas as configurações adequadas em seu sistema, um desktop Ion3 não deixará nada a desejar com relação a desktops tradicionais como GNOME e KDE.

Depois de acostumado ao modelo de tiling, um usuário deverá sentir até mesmo certa dificuldade ao utilizar novamente gerenciadores de janela tradicionais (não-tiling).

Tentei passar neste artigo toda a minha experiência em configuração de desktops, esgotando completamente tudo o que eu teria para falar. Espero que o conteúdo aqui apresentado possa auxiliar muitos usuários a ingressar no maravilhoso mundo do tiling, não somente com o Ion3, mas também com outros igualmente excelentes gerenciadores janelas como dwm, wmii e xmonad.

Outras referências

• Configuring and Extending Ion3 with Lua - Este manual explica o funcionamento interno do Ion3 e como escrever novos scripts em Lua para ele. Muito indicado para usuários que queiram se aprofundar.