Bryan Garber’s Blog

Recentemente precisei descobrir, usando C, o tempo de execução de um processo. Ao invés de tentar um simples system(“ps aux | grep <pid>”), pensei em utilizar algo mais esperto: a árvore montada no /proc. O /proc mantém em sua estrutura de diretórios arquivos para cada processo sendo executado na máquina, tendo um diretório específico para cada PID. Bom, não vou entrar em detalhes sobre como está organizado o /proc neste post, mas podemos encontrar uma boa referência aqui.

Como podemos ver na lista de arquivos dentro de /proc/<pid>, o diretório de cada PID possui um arquivo chamado stat. Uma das várias informações guardadas neste arquivo é o starttime. Então a primeira coisa que vamos fazer é abrir o stat do PID desejado no nosso programa:

char stat_file[80];
unsigned int pid;
 
if ( ac < 2 )
{
    printf("Error: one argument is needed!\n");
    exit(1);
}
pid = atoi(av[1]);
 
snprintf(stat_file, sizeof(stat_file), "/proc/%d/stat", pid);
proc_time = fopen(stat_file, "r");
if ( !proc_time )
{
    printf("Some strange error occurred while opening the file!\n");
    exit(1);
}

Com o stat do processo aberto, podemos procurar a 22ª string deste arquivo, que refere-se ao campo starttime do processo.

freadln(&line, proc_time);
char *jiff_from_boot_str = s_token(line, " ", 22);
long int jiff_from_boot = atoi(jiff_from_boot_str);

Onde as funções freadln e s_token são definidas como:

size_t freadln (char **line, FILE *stream)
{
    char c;
    unsigned int counter = 0;
 
    fread(&c, 1, 1, stream);
    while ( (c != '\n') && (!feof(stream)) )
    {
        counter += 1;
        (*line) = realloc((*line), counter * sizeof(char));
        (*line)[counter - 1] = c;
 
        fread(&c, 1, 1, stream);
    }
 
    counter += 1;
    (*line) = realloc((*line), counter * sizeof(char));
    (*line)[counter - 1] = '\0';
 
    return counter - 1;
}
 
char* s_token (char* str, char* sep, int i)
{
    char *s = (char *) strdup(str);
    char *ret = strtok(s, sep);
 
    i--;
    while (i > 0){
        ret = strtok(NULL, sep);
        i--;
    }
 
    if (!ret) return NULL;
 
    return ret;
}

A primeira função serve para ler uma linha de um arquivo (não gosto de sscanf ou fgets ) e a outra serve para ler tokens de uma string a partir de um delimitador sem alterar a string original.

Como podemos reparar, o campo starttime no arquivo stat não está em segundos. Está em jiffies (um tipo de tick de relógio do Linux). O valor de jiffies por segundo é configurado na compilação do kernel. Para obter este valor, temos que realizar a seguinte consulta:

long int jiffies_per_sec = sysconf(_SC_CLK_TCK);

Agora fica fácil descobrir quantos segundos tinha se passado desde o boot até o início do programa. Basta dividirmos jiff_from_boot por jiffies_per_sec! Mas como queremos o tempo de execução do programa, vamos esperar para adicionar na fórmula final. Como pode-se imaginar, iremos calcular o tempo de execução do programa obtendo o tempo em segundos desde o boot do kernel (uptime) e subtrair pelo segundo de início do programa em questão. Para isso, iremos consultar usando a estrutura sysinfo.

struct sysinfo sys_inf;
sysinfo(&sys_inf);

Pronto. Esta estrutura já possui um campo com o uptime em segundos, então basta resolver a diferença!

long int proc_rtime = sys_inf.uptime - jiff_from_boot/jiffies_per_sec;
printf("Process %d running time: %ld secs\n", pid, proc_rtime);

Bom, acho que é isso. Caso queiram dar uma olhada no meu arquivo C, ele está disponível aqui. Nele poderás ver os includes necessários para compilar o teu código-fonte.

GNU/Linux sempre foi um dos meus sistemas operacionais favoritos. A minha distro Linux de uso diário é o Debian. Eu gosto muito do “controle das coisas” que ele propicia, mas tenho altos e baixos com a visão estreita que a distro tem sobre Free Open Source. Eles levam o assunto muito a sério, como podemos ver nas notícias que eles, finalmente, “libertaram” todo o kernel Linux. Bem, esse post não veio para falar de Linux. Conhecendo Linux, é inevitável não conhecermos o Unix, o precursor disso tudo. O Unix é o “pai-de-todos”. A partir dele, conhecemos o BSD (SO criado pelo pessoal da UC Berkeley – Universidade da Califórnia), o Minix (criado por Andrew Tanenbaum, com propósitos educacionais), o Linux (criado por Linus Torvalds, a partir de seus interesses no Minix) e ainda existem vários outros que foram criados em cima da ideia do Unix. Vejam só, o Mac OS sempre foi baseado no Unix, mas passou a ser baseado no BSD a partir da sua versão X. Então podemos dizer que o Unix ainda é bastante presente nas nossas vidas (ainda não tanto entre os usuários comuns, mas vem ganhando espaço a cada dia). A partir do BSD, que acabou tornando-se um sistema operacional bastante restrito devido à várias fabricantes o terem adotado na época, foi criado o FreeBSD, que procurou a liberdade para o BSD, e o mantém livre até o momento. E é nesse cara que vou me focar a partir daqui.

Instalação Básica

A versão atual do FreeBSD é a 8.1 e pode ser baixada aqui. Eu preferi baixar a versão bootonly. Antes de continuarmos, recomendo que experimentem a instalação em uma máquina virtual, para evitar dores de cabeça mais tarde. Se gostares do sistema, poderás instalar na tua máquina real, seguindo praticamente os mesmos passos (e cuidando para não sobrescrever os SO’s existentes), daí já com a experiência de ter instalado uma vez. Aviso que FreeBSD definitivamente não é um SO recomendado para iniciantes, então muita cautela. Também coloco aqui que o FreeBSD é um sistema demorado e difícil de configurar. Tu não terás um sistema rodando antes de perder uns 2 dias (na melhor das hipóteses) configurando e instalando, enfrentar o grande dragão Smaug em sua Montanha Solitária, derrotar Saruman e seu terrível exército de uruk-hais abomináveis e derrubar o grande Olho Vermelho de Sauron, o Senhor do Escuro, em sua Torre Escura Barad-dûr, e seus terríveis Espectros do Anel, não necessariamente nesta ordem.

Bem, voltando ao que interessa:

1. Uma vez iniciado o disco, ele irá inicializar o sistema básico, irá perguntar o país e irá cair em um menu com várias opções: um manual de referência e as opções de instalação. Selecionaremos a opção de instalação “Standard”.
2. Os próximos três passos serão de reserva de espaço em disco, seleção do boot manager e configuração das partições do FreeBSD. Como eu estou utilizando uma VM, simplesmente pedi para usar todo o disco, usar o boot manager padrão (Standard) e usar a configuração automática para as partições do FreeBSD. Cuide para não sobrescrever teus SO’s já existentes, caso já esteja instalando na tua máquina. O FreeBSD reconhecerá automaticamente tua tabela de partições no fdisk.
3. Após configuradas as partições, ele pedirá para escolher a distribuição a ser instalada. Eu recomendo selecionar (e marcar pressionando a tecla “Espaço”) a distribuição “User” e selecionar os manuais em inglês no menu seguinte. Quando selecionado, aperte “Tab” para selecionar o botão “Ok” e pressione “Enter”.
4. A próxima janela irá perguntar se queres instalar as coleções do ports. O ports é uma árvore de direrórios para instalar novos softwares, como explicarei mais tarde. Selecione “Yes” nesta etapa, pois o ports será necessário mais tarde.
5. A janela de seleções de distribuições será apresentada novamente, pressione “Tab” para selecionar o “Ok” e aperte “Enter”, para irmos à próxima etapa da instalação.
6. A janela que será apresentada pedirá para selecionarmos a mídia de instalação do sistema. Como baixamos a versão bootonly, vamos selecionar via FTP. Atenção: pode ser que, na hora de baixar os pacotes dos servidores FTP, ocorram erros ao tentar contactar o site. Isso provavelmente significa que tem algum firewall bloqueando a conexão. Para superar isso, voltamos para esta janela e selecionamos via FTP Passivo (FTP Passive).
7. Na próxima etapa, devemos selecionar o servidor que iremos baixar os pacotes. Recomendo usar o “Main Site” (ftp.freebsd.org).
8. O instalador irá perguntar se queres tentar conexões IPv6 na interface. Como ainda é difícil termos suporte a esta tecnologia, vamos selecionar “No”.
9. A próxima pergunta é se queremos tentar a configuração via DHCP. Para esta pergunta, respondemos “Yes”.
10. Então, nos será pedido para colocar o nome do máquina em “Host”. O domínio e as outras informações já deverão estar preenchidos automaticamente, mas não custa conferir se está tudo certo. Navegue pelos itens com o “Tab”, deixe em branco o campo de “Extra options” e selecione “Ok” e pressione “Enter”.
11. Será feita uma pergunta de última chance antes de se gravar as mudanças em disco. This is the point of no return. Se estiveres certo com tudo que foi feito, apenas pressione “Enter”.
12. Aguarde, a instalação irá começar. Isso levará algum tempo, dependerá da tua velocidade de conexão e da capacidade de processamento da tua máquina. Aproveite e tome um cafézinho… A instalação até aqui não foi muito dolorosa, o pior ainda está por vir….
13. Ao final, uma tela parabenizando pela finalização da instalação será apresentada. Agora vamos configurar algumas outras coisas… Apresentarei cada pergunta e cada resposta em cada um dos próximos itens.
14. Network gateway? “No”.
15. Configure inetd and network services? “No”.
16. SSH login? “Yes”.
17. Anonymous FTP? “No”.
18. NFS server? “No”.
19. NFS client? “No”.
20. Customize console settings? “No”.
21. Set time zone now? “Yes”.
22. As próximas janelas são de configuração do relógio, selecione “No” para a pergunta se o relógio da CMOS está em UTC (ou “Yes”, se tu tens certeza de que está). Selecione região e fuso nas próximas janelas; o instalador irá perguntar se a sigla BRST faz sentido, responda “Yes”.
23. Configure mouse? “Yes”.
24. Na próxima tela, selecione “Enable”, teste e verifique existe um ponteirinho se mexendo na tela. Caso ok, selecione “Ok” e selecione “Exit” no menu anterior.
25. A próxima janela irá perguntar se tu queres navegar pelos repositórios de pacotes para adicionar alguma coisa à instalação. Selecione “Yes”. Navegando nas categorias da próxima janela, selecione: gnome e marque gnome2-2.30.1_1 na lista seguinte. Isso marcará todas as dependências dele. Selecione alguns temas para GTK e Metacity que estão disponíveis na lista, são bastante bons. Pressione “Ok” e voltaremos a tela de categorias anterior. Selecionamos a categoria x11, e marcamos o pacote xorg-7.5. Suas dependências serão marcadas.
26. Na próxima janela, confirme os pacotes a serem instalados pressionando “Ok”. Caso o instalador pergunte, vamos selecionar novamente o “Main Site” para baixar os pacotes. O instalador comentará que as configurações de rede aparentemente já foram feitas, confirme isso pressionando “Ok”.
27. Mais uma longa espera… Eu disse que isso iria demorar… Hehehehe… Repare agora que não conseguimos ter ideia nenhuma se já estamos quase terminando ou recém começando. Bad FreeBSD! No donuts for you! Repare que, ainda por cima, os pacotes do X11 não são marcados por padrão quando selecionamos o Gnome2. Muy malo!
28. Após a instalação dos pacotes, vamos criar novos usuários para o sistema e novos grupos. Mantendo a tradição “Linux”, vamos primeiro criar um grupo especial para o usuário (em geral, com o mesmo nome do usuário) e vamos criar o usuário, adicionando o grupo criado anteriormente como grupo do usuário. Por exemplo usuário bgarber e grupo bgarber.
29. Agora estamos de volta ao menu inicial. Simplesmente selecione “Exit install” e aperte “Enter”.
30. O instalador irá avisar que vai reiniciar a máquina, pressione “Ok” e certifique-se de remover os discos, para não entrares na instalação novamente.

Pronto, temos o sistema básico funcionando. O que eu achei de errado no instalador do FreeBSD é que, enquanto ele está instalando pacotes adicionais, não se dá pra ter ideia de quanto já foi concluído. Podiam ter um pouco mais de informações estas telas! Além de tudo, ao fazer reboot, verás que a interface gráfica não carregará imediatamente… Isso por que teremos que configurar mais algumas coisas, o que explicarei logo em seguida…

pkg_add, pkg_delete e ports

Bem, depois da instalação do sistema, acho que faz sentido falarmos um pouco sobre a instalação de pacotes no FreeBSD. São oferecidas duas formas de instalar novos softwares: ou a partir dos pacotes pré-compilados usando pkg_add, ou compilá-los manualmente usando a árvore do ports. Antes de usarmos estas ferramentas, é interessantes rodarmos os seguintes comandos:

# freebsd-update fetch install
# portsnap fetch extract

O primeiro comando irá atualizar o sistema e o segundo irá baixar e instalar a árvore de diretórios do ports.

Falando, então, do pkg_add. Ele é usado para instalar novos pacotes e, em geral, é executado da seguinte forma:

# pkg_add -r <packet_name>

Portanto, se eu fornecer “vim” no lugar do “<packet_name>”, o FreeBSD irá instalar, a partir dos repositórios remotos (reconhecido pelo argumento “-r”) o “vim”. O pkg_add irá resolver as dependências e instalá-las.

De forma inversa ao pkg_add, o pkg_delete é utilizado para remover pacotes instalados no sistema. Cuidado, pois ele se recusará a desinstalar um pacote que possui outros pacotes que dependam dele. Recomendo a leitura dos manuais dos comandos.

O ports é uma versão mais “mão-grande” do pkg_add. Enquanto o pkg_add fornece pacotes pré-compilados, o ports baixa, compila e instala cada dependência para um programa que deve ser instalado. Mas não se iluda, isso pode parecer muita coisa, mas muitas vezes é o mais recomendado. O ports em si não é um comando, é uma estrutura de diretórios. Dentro de /usr/ports veremos uma lista de diretórios, dividindo os pacotes por categorias. Entramos no diretório da categoria, entramos no diretório do pacote, executamos make install clean e o pacote e suas dependências não satisfeitas serão baixadas, compiladas e instaladas. Um exemplo, usando o pacote do vim:

# cd /usr/ports/editors/vim
# make clean install

Pronto. Recomendo dar uma olhada nas categorias e uma navegada pelos diretórios. Instalar pacotes pelo ports vai demorar um pouco mais do que de costume, mas vale a pena. Para remover algum pacote, basta executar make deinstall, dentro do diretório do pacote.

Configurando o X.org, o GDM e o Gnome

Como vocês devem ter reparado, ter instalado os pacotes do Gnome e do X.org não fez com que nenhuma interface gráfica fosse carregada, no momento. Isso é porque o FreeBSD não configurou para carregar os módulos deles em tempo de boot. para carregar a interface gráfica por padrão no momento do boot, basta adicionar as seguintes linhas no arquivo /etc/rc.conf:

dbus_enable="YES"
hald_enable="YES"
gdm_enable="YES"
gnome_enable="YES"

Além disso, devemos configurar o kern.maxfiles. Esta é uma das variáveis dos “tunables“, o que quer dizer que podemos otimizar a performance do FreeBSD. Devemos atualizar este valor, que indica o máximo de arquivos que podem ser abertos ao mesmo tempo no sistema. A alteração é feita no arquivo /boot/loader.conf, adicionando a seguinte linha:

kern.maxfiles=20000

Por fim, teremos que adicionar no /etc/fstab para montar o /proc. Isso se faz necessário, pois sem isso o GDM não exibirá os usuários do sistema.

proc   /proc   procfs   rw   0   0

Dicas Finais

• Use o /usr/ports. É a melhor maneira de instalar novos programas.
• Permita que um usuário possa fazer “su -” (para acessar a conta de root) adicionando-o no grupo wheel.
• Se estiver numa VM VirtualBox, instale os guest additions! Basta irmos no ports do FreeBSD /usr/ports/emulators/virtualbox-ose-additions; executar make install clean; executar Xorg -configure; copiar o xorg.conf.new para o /etc/X11; e atualizar o /etc/X11/xorg.conf, trocando a opção “Driver” da sessão “Device” para “vboxvideo” e a opção “Driver” da sessão “InputDevice” para “vboxmouse“.
• Às vezes o GDM não inicia assim, tão automaticamente. Recompilá-lo pelo ports (/usr/ports/x11/gdm; make deinstall; make reinstall clean) é uma boa ideia. Quando fizer o reboot, pode ser que ele ainda assim não inicie de primeira, entre como root e execute gdm restart. Agora ele tem que iniciar e provavelmente passará a funcionar no boot.
• Minha experiência diz que coisas obscuras podem acontecer enquanto estiveres usando o FreeBSD. Não tenha medo de buscar as informações na internet!
• Tenha paciência. O FreeBSD é um sistema lento quando instalado pelos pacotes pré-compilados. Recompilar o kernel, otimizando para o teu caso, é uma boa ideia (tem um manual de como fazer isso aqui).

Bem, este foi um artigo bastante longo e cansativo. Aproveite seu novo sistema operacional.

On a day-to-day routine of programming in C, it’s a common practice declare a special type for “unsigned int” (or even creating macros). The following lines show some of this practice:

#define U32    unsigned int
#define UINT32 unsigned int
 
typedef unsigned int UINT32

Remember that these all declarations are “unsigned”. I comment this because I’ve already seen codes such like:

typedef struct _foobar {
    UINT32 u32_field;
} foobar;
 
// code goes on...
...
 
foobar *some_struct_ptr;
some_struct_ptr = (foobar *) malloc(sizeof(foobar));
 
// more code...
...
ASSERT(some_struct_ptr->u32_field >= 0);

What’s wrong here? The ASSERT call is always true! So this is an unnecessary test! This does not affect the code execution at all, but in greater projects, where the CPU cicles are so precious as diamonds, or if you want to deliver a code that is clean of warnings while building your source, you will need to remove these kind of calls.

A dura verdade…

O meu primeiro sistema operacional que instalei foi um Kurumin 3.0, que eu usava num computador velhão aqui de casa. Instalei Linux antes mesmo de ter alguma experiência instalando Windows. E desde que instalei pela primeira vez com sucesso um sistema operacional, não parei mais. Gosto muito de instalar sistemas operacionais, experimentar na segurança de uma VM (uso VirtualBox) ou instalando nas minhas máquinas. Nessa minha vida de nerd, depois de instalar o Kurumin, já instalei o Windows XP, o Ubuntu (moleza…), o FreeBSD, o Gentoo, Minix 3, o Debian, e mais recentemente o Windows Vista e o Arch Linux. Mas eu, como um usuário entusiasta do Debian, já o instalei de várias maneiras diferentes.

Como eu costumo comentar com meus colegas e amigos, o Debian tem, pelo menos 4 modos de instalação: o modo usuário (o qual já comentei aqui), o modo normal (que seria basicamente procedendo pelos passos de instalação com o instalador padrão), o modo difícil (o que eu costumo fazer, trata-se de instalar o básico do básico pela instalação normal e instalar o restante via apt-get – inclusive o X! -, uso muito para instalar a versão testing através do CD de instalação do stable) e o NERD way. Este último é o nível que supera em dificuldade o modo difícil, mesmo usuários experientes podem “se quebrar” tentando. Os passos para o NERD way são para pessoas experientes, que sabem o que estão fazendo. Se quiser experimentar, recomendo usar uma máquina virtual, para brincar. Daí, não se corre o risco de danificar as partições do próprio disco.

Antes de qualquer coisa, precisaremos de uma distro live CD qualquer. Eu utilizei o live CD do Ubuntu 10.10, mas pode ser qualquer uma que tenha a possibilidade de executar sem fazer nenhuma instalação. A partir daqui, seguimos os seguintes passos:

1. inicializamos o live CD, entrando no Gnome Desktop;
2. esta instalação irá usar o debootstrap, que é um utilitário que várias distribuições possuem, portanto vamos abrir um terminal e instalá-lo:

$ sudo apt-get install debootstrap

3. após terminar de instalar com sucesso, vamos executar o cfdisk;
4. no cfdisk, vamos criar 3 partições: uma para o /, uma para o /home e uma para o swap, de acordo com a imagem abaixo (clique na imagem para ampliar):


Tabela de partições do disco.

5. os rótulos das partições não foram colocados quando tirei a screenshot acima, mas a saber, o sda1 irá mapear para uma área de swap, o sda2 irá mapear para o / e o sda3 irá mapear para o /home;
6. após terminado o particionamento do disco, vamos gravar as alterações (NOTA IMPORTANTE: este processo é irreversível! Muito cuidado!), talvez um reboot seja necessário (se for, reinstale o debootstrap ao reiniciar, óbvio);
7. agora, vamos formatar as partições criadas; meu sistema de arquivos escolhido será o ext4 e lembrando que as partições, no meu caso e provavelmente o teu,  ficaram nos discos mapeados como /dev/sda*:

$ sudo mke2fs -t ext4 -L / /dev/sda2
$ sudo mke2fs -t ext4 -L /home /dev/sda3

8. vamos ativar a área de swap:

$ sudo mkswap /dev/sda1
$ sudo swapon /dev/sda1

9. vamos montar a partição / (eu preferi no /mnt):

$ sudo mount /dev/sda2 /mnt

10. agora, estamos prontos para o debootstrap:

$ sudo debootstrap squeeze /mnt http://ftp.br.debian.org/debian

11. isto irá instalar o básico do básico na partição, não vai ter nem kernel instalado; este processo irá demorar um pouco, aproveite para tomar um cafézinho…
12. ao concluir a instalação, vamos fazer um chroot para o diretório onde a partição / foi montada:

$ sudo chroot /mnt

13. agora precisaremos instalar o kernel; aproveito a oportunidade e instalo mais algumas coisas que poderão ser úteis, como linux-headers, make, etc…

# aptitude install linux-image-2.6.32-5-686 \
    linux-headers-2.6.32-5-686 make vim

14. espere concluir a instalação, se ele reclamar de “untrusted packages“, apenas digite “Yes“, que isso pode ser resolvido mais tarde (também não se preocupe com o possível warning: can’t open /etc/mtab: No such file or directory);
15. a seguir, vamos configurar o /etc/fstab (sim, temos que fazer isso, eu avisei que seria bem manual no início do post); vamos configurar para ele se parecer com isto:

#<file system> <mount point> <type> <options> <dump > <pass>
/dev/sda1      swap          swap   defaults  0       0
/dev/sda2      /             ext4   defaults  1       1
/dev/sda3      /home         ext4   defaults  1       2

16. após o fstab, vamos instalar o grub no setor de inicialização:

# aptitude install grub
# cd /dev
# mknod sda b 8 0
# mknod sda1 b 8 1
# mknod sda2 b 8 2
# mknod sda3 b 8 3
# grub-install sda
# update-grub2

17. caso a operação de aptitude install do grub reclame que tu estás instalando o grub sem instalá-lo em nenhum disco, diga que é para ele seguir mesmo assim; repare que nós temos que criar cada /dev/sda*, pois eles ainda não aparecem na listagem do diretório;
18. por final, vamos configurar a rede, utilizando por base a distro do live CD, copiando os seguintes arquivos:

# exit
$ sudo cp /etc/hosts /mnt/etc
$ sudo cp /etc/network/interfaces /mnt/etc/network/

19. e não vamos esquecer de editar o /mnt/etc/hostname com o nome desejado para máquina; adicionalmente, troque o “ubuntu” (depende do live CD que tu estiveres usando, eu estou usando o Ubuntu aqui) do arquivo /mnt/etc/hosts pelo mesmo nome colocado no /mnt/etc/hostname; repare ainda que, neste momento, nós saímos do modo chroot;
20. adicione as seguintes linhas no /mnt/etc/network/interfaces:

auto eth0
iface eth0 inet dhcp

21. Update: uma alternativa ao passo anterior é instalar o pacote network-manager via apt-get!
22. vamos voltar ao chroot (sudo chroot /mnt) e trocar a senha do root com passwd;
23. e agora é hora (enfim!) de dar adeus ao live CD e dar reboot no teu novo sistema operacional! \o/

Para a instalação, é isso. Configure novos usuários usando adduser login (substitua login pelo nome de usuário que tu desejar) e instale novos pacotes a vontade. Para instalar o Gnome, execute aptitude install gnome. Ou simplesmente execute tasksel, para automatizar esta instalação de pacotes adicionais.

É possível que tenhas que reconfigurar o layout de teclado no terminal (onde não tem a interface gráfica carregada). Isso se resolve com “dpkg-reconfigure console-data” e selecionando o mapa de teclados corretamente das listas (resolvi selecionando “pc / qwerty / Brazilian / Standard / Standard ABNT2″ da lista completa de mapas de teclado). O problema com “untrusted packages” no apt-get eu resolvi apenas executando um apt-get update. Não esqueça de atualizar teu /etc/apt/sources.list com outros repositórios. Aqui vai como está o meu:

deb http://ftp.br.debian.org/debian/ squeeze main contrib non-free
deb-src http://ftp.br.debian.org/debian/ squeeze main contrib non-free
 
deb http://security.debian.org/ squeeze/updates main contrib non-free
deb-src http://security.debian.org/ squeeze/updates main contrib non-free

É isso. Espero ter ajudado ao nerd que se interessar por este processo.

Concentração nas tarefas que devem ser realizadas têm se tornado um problema, principalmente para nós que trabalhamos praticamente 12 horas diárias em cima de um computador com acesso a internet e a um mundo de informações. E esse mundo de informações nos faz esquecer daquilo que devemos fazer e, no final das contas, ficamos “correndo contra o tempo” para conseguir concluir as tarefas dentro do prazo.

Algumas semanas atrás, eu descobri uma maravilha: algo chamado Pomodoro Technique. A técnica Pomodoro, como prefiro chamá-la, é uma forma de controlar a ansiedade e o tempo, para que pessoas como eu (que se distraem facilmente com qualquer coisa), consigam manter o foco e concluir as tarefas importantes. Aqui, venho compartilhar como estou aplicando nas minhas tarefas e minhas impressões. Os passos para seguir são simples:

1. anote uma lista de tarefas para serem realizadas;
2. pegue a tarefa de maior prioridade (ou a do topo da lista, a escolha é sua);
3. inicie um contador de tempo para contabilizar 25 min (a recomendação original é usar um relógio contador de cozinha, mas isso parece ser um artigo raro hoje em dia; pode ser um cronômetro qualquer, eu uso o timer-applet no meu Gnome Desktop);
4. trabalhe focado na tarefa (focado, por favor, sem desviar) até o cronômetro despertar (chamamos este período de 1 pomodoro);
5. descanse por 5 min;
6. inicie o próximo pomodoro, trabalhando na mesma tarefa anterior ou, se foi concluída, pegando a próxima tarefa;
7. a cada 4 pomodoros, tire um tempo de descanso mais longo (15 min) e, depois retorne a normalidade (descansos de 5 min depois de cada pomodoro).

O único ponto fraco da técnica Pomodoro é que não trata de forma “tranqüila” as interrupções que podem acontecer durante um pomodoro. O que eu tenho feito: quando tenho uma interrupção que prevejo ser breve, eu simplesmente paraliso o contador, faço o que tenho que fazer, e volto para o pomodoro de onde parou; caso, a interrupção for longa, no retorno, inicio um novo pomodoro, como se eu tivesse tipo um tempo de descanso imprevisto. NOTA IMPORTANTE: essas interrupções são exceções! Auto-controle e comprometimento com a técnica são essenciais aqui. Essas interrupções não são “geradas” por mim, são quando outra pessoa, por um motivo qualquer, interrompe-me.

A cheat sheet da técnica ainda tem outras dicas. Recomendo sua leitura. Talvez, uma adaptação para o teu cenário seja necessária, como fiz para tratar as minhas interrupções imprevistas de pomodoro. Os meus resultados têm sido excelentes. Em pouco tempo, mesmo sem o contador, consegui treinar meu cérebro a dar foco naquilo que preciso fazer. Um resultado impressionante para alguém que, por qualquer motivo, distraía-se com qualquer bobagem na internet.

Não adianta tentar escapar: todos nós, uma hora ou outra, temos que fazer alguma apresentação, seja na escola, na faculdade ou no trabalho. O que mais me surpreende é a quantidade de pessoas que simplesmente não sabem como fazer uma boa apresentação de slides para trabalhos, tanto profissionalmente quanto no meio acadêmico. Através deste post, quero deixar registrados algumas dicas do que aprendi com o tempo e do que me ensinaram para fazer uma boa apresentação.

1. Evite muito texto nos slides.

Lembre-se: os slides existem como um roteiro para guiar a tua apresentação, não para apresentar todo o conteúdo. Prefira uma estrutura em tópicos, colocando no máximo 2 linhas (e estou sendo muito generoso) para cada tópico. Caso o tópico exija mais que 2 linhas, considere quebrá-lo ou resumir em palavras que sejam fáceis para relembrar do assunto.

Muito texto nos slides podem levar o teu público a fazer duas coisas: pensar que tu não sabes/entendes do que tu estás falando e desviar a atenção do que tu estiver falando para ler os slides. Isso nos leva ao segundo ponto.

2. Procure manter a atenção das pessoas focadas no que tu estiver falando.

Isso é obtido através do primeiro item. Tendo pouco texto nos slides, o público levará menos tempo para lê-lo e terá tempo de voltar a atenção ao que tu estiver falando.

Procure manter um discurso fluente e claro, que todos possam entender o assunto que está sendo tratado. Isso ajuda muito em manter a atenção do público.

3. É terminantemente proibido ler (em voz alta) os slides.

Ainda ligado com o primeiro item, ficar lendo os slides torna a apresentação sem sentido e, como um todo, aborrecedora. Pode deixar a impressão que tu, ao criar a apresentação, não deste a mínima atenção para o que estava escrito e/ou não entendeste o assunto.

4. Também é proibido ler papéis.

Pelos mesmos motivos do item 3, evite levar e ler papéis com o texto da apresentação para o momento de apresentar o assunto. Nesse caso, pode ser feita uma exceção quando é extremamente necessária uma citação de um documento (tipo uma carta, um jornal, etc.) que pode provar algo que tu estejas apresentando. Mas este tipo de situação dificilmente irá ocorrer e sempre será melhor se tu não tiver que ler algum papel durante a apresentação.

5. Cuide de sua aparência.

Cuide sempre para que tua aparência esteja de acordo com a ocasião da apresentação. Uma aparência que possa parecer fora de contexto pode levar o público a não levar a sério a apresentação.

6. Para os mais retraídos: tenha sempre algo pequeno para segurar nas mãos.

Um lápis, uma caneta, um clips. Qualquer coisa que, num momento de tensão, tu possas utilizar para “descarregar” o nervosismo. Nestes momentos, segure com força o objeto respire fundo e resolva da melhor maneira o “conflito”, seja dando uma boa resposta a um questionamento ou uma crítica. Acreditem em mim: funciona. Sou prova viva disto.

7. Permita-se momentos de descontração.

Moderação neste item! Sempre cuide do contexto e se o humor será apropriado ao momento. Procure não ofender ninguém! Mas um pouco de descontração é bom até mesmo para tu, que irás apresentar, dar uma relaxada e não ficar muito nervoso. Sempre cuide para não perder o foco dos objetivos e da seriedade que é implícita a apresentação! Como no item anterior, sou prova viva de que isto funciona.

Bom, eram estas minhas dicas. Quem quiser, contribua nos comentários com mais algum ponto que seja importante.

Mais um post programador-geek-útil: bit-fields. Para quem não conhece, em C pode-se criar coisas “bizarras” do tipo estruturas com campos de tamanho 1, 2 ou n bits. Sim, eu não me enganei. É isso mesmo o que tu entendeu. Em C podemos criar estruturas com campos de apenas 1 bit, por exemplo. Aliás, por sinal, tu pode até mesmo criar uma estrutura com apenas 1 bit.

“Mas como isso?” tu te pergunta. É mais fácil do que parece. Basta declarar a estrutura e, para cada campo, dizer quantos bits tu quer. Simples assim:

struct byte_t {
    unsigned char high: 4;
    unsigned char low:  4;
};

Neste caso, estamos declarando uma estrutura com dois campos, cada um com 4 bits. Viram como é simples? Neste caso, nossa estrutura terá o tamanho de 8 bits, 1 byte no final das contas. Mas nada me impede de declará-la assim:

struct bit_t {
    unsigned char val: 1;
};

Agora temos uma estrutura de apenas 1 bit de tamanho! Faça o teste: tente colocar algo mais do que 0 ou 1 no campo val da estrutura para ver se o GCC não reclama com um warning!

Algo que preciso lembrar é que o comando sizeof() não irá funcionar para a estrutura bit_t. Porque? Ora, é óbvio. A função sizeof() retorna seus valores em bytes e não em bits. Já para a estrutura byte_t, nós conseguimos executar o sizeof(), já que seu tamanho é de exatamente 1 byte.

Update: como comentado pelo meu amigo Fabio Utzig, o tamanho das estruturas em si serão arredondadas para a representação. Por exemplo, caso eu adicione mais um campo na estrutura byte_t, mesmo que seja de um bit apenas, o tamanho total da estrutura será 2 bytes, pois ele arredonda o tamanho. Os campos em si que sempre terão o tamanho em bits especificado.

Neste semestre, estou fazendo a cadeira de Projeto de Sistemas Operacionais na faculdade. Por opção, resolvi (em conjunto com alguns colegas) usar o Minix 3 como sistema operacional de estudos. Instalei ele, feliz da vida, numa máquina virtual do VirtualBox. O problema é que a rede não queria de jeito nenhum funcionar! A princípio deveria funcionar, escolhi o driver certo na instalação (AMD Lance, emulado pelo VMWare e pelo VirrtualBox), mas não funcionava. Depois de muito pesquisar, consegui fazer funcionar. Aqui vão as dicas!

Depois de completada a instalação do Minix 3, reinicie o sistema (não esqueça de botar no VirtualBox para ele não montar o cdrom do Minix3) e execute primeiramente estes passos:

1. Com o sistema reiniciado, coloque a imagem do CD do Minix 3 de volta.
2. Como root, execute “packman”.
3. Procura o número do vim, para instalá-lo do CD… ;-P
4. Cuidado para não deixar ele tentar atualizar a lista de arquivos da internet (o que tu não tem ainda… hehehehe…)

Estes foram somente os passos para instalar o vim… hehehehe… Os passos que segui para fazer a rede funcionar no Minix 3 foram estes:

1. Edite o arquivo “/usr/etc/rc” (com o vim).
2. Vá para a linha 82; ela diz “Starting services:”.  Vá para a  próxima linha;  ela começa com “up random”.
3. Aperte “v” (para entrar em modo visual) e vá selecionando até o primeiro “fi” que tu encontrar.
4. Recorte estas linhas.
5. Agora, vá até a linha que diz “up inet”.
6. Cole as linhas que tu copiaste logo em cima desta linha.
7. Vá para baixo, até onde diz “intr -t 20 hostaddr -h” (use o “/” do vim).
8. Mude o “20″ para “30″

Esta é a primeira parte da solução… hehehehe… Agora vamos para o kernel…

1. Dá um cd /usr/src/drivers/lance
2. vim lance.c
3. A partir da linha 632, edite da forma como segue.
4. Comente as seguintes linhas:

if (ec->ec_linmem != 0)
{
    assert( 0 );
    /*phys2seg(&ec->ec_memseg, &ec->ec_memoff, ec->ec_linmem);*/
}
 
/* XXX */ if (ec->ec_linmem == 0) ec->ec_linmem= 0xFFFF0000;

5. E adicione a seguinte linha:

ec->ec_linmem= 0xFFFF0000;

6. Salve o arquivo e saia do vim.
7. Vá até a pasta /usr/src/ e execute o seguinte comando:

# make world

8. Vai demorar uns 15 ou 20 minutos, aproveite para tomar um cafézinho…
9. Reinicie o Minix 3 (não esqueça de desmontar a imagem do cdrom do VirtualBox…).
10. Depois de reiniciado, dê um ps ax | grep lance.
11. Com o PID do driver de rede (provavelmente, será 55), nós vamos nos aproveitar do Reincarnation Server do Minix 3 e matar o processo do driver de rede. Sim, isso mesmo:

# kill -9 55

12. O RS vai verificar a morte do processo driver e reiniciá-lo, agora sim a rede vai estar funcionando 100%.

O único problema é que toda a vez que reiniciarmos o sistema teremos que executar o comando kill. Mas, por mim, tá tudo bem.

É… Quero dizer… Hmmm… Digamos meia boca… Como prometi há algum tempo atrás (bota tempo atrás), estou disponibilizando aqui um meio fácil de “botar para funcionar” o Tibia com o Wine. Só os resultados deixaram a desejar um tanto… =/ O melhor DirectX que ele conseguiu compatibilidade foi o 5, portanto os gráficos ficaram bem ruinzinhos e sem opções de “sombra”. O que deve ser feito para o Tibia funcionar com o Wine é alterar os registros dele. Como se fosse um Windows mesmo, o Wine tem seu regedit. Para acessá-lo, basta executar o seguinte comando no terminal:

$ regedit

Isto irá abrir, com o Wine, uma janela como a qual já devemos conhecer do Windows (pelo menos aqueles que gostam de brincar com o editor de registros… =P). Com a janela aberta, expandimos o HKEY_CURRENT_USER->Software->Wine->Direct3D. Dentro desta pasta devemos modificar o seguinte registro: DirectDrawRenderer. O valor dela deverá ser alterado para “gdi” (sem as aspas, é claro). Para alterar o valor do registro, basta clicar com o botão direito em cima do registro, clicar em modificar e alterar o campo “Dados do valor”. Caso não exista nenhum registro dentro de Direct3D, basta adicioná-lo, clicando no botão “Editar”, na barra de menu, selecionar “Novo->Valor Texto”. Altere o nome do registro para DirectDrawRenderer e, após isso clique com o botão direito em cima do registro recém criado, clique em Modificar e altere o valor do campo para “gdi”. Pronto. Na próxima vez que o Tibia for aberto com o Wine, tudo deverá funcionar corretamente.

Pelo Wine, conseguimos até apenas o DX5, o que faz percebermos grande perda de qualidade.