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.

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.

$ 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.

# make menuconfig

Este comando abrirá uma interface colorida para configuração do kernel a ser compilado. Altere a seu gosto, mas com cuidado. Não vou entrar em detalhes sobre como configurar o kernel para sua máquina aqui pois não é este o objetivo do artigo, mas recomendo executar alguns lspci, e buscar informações na internet (leia-se Google ) caso tenha que configurar algo em especial. Em geral, o kernel já vem com uma configuração por padrão que atende a maioria dos casos. Sempre existe a possibilidade de se copiar o arquivo de configuração do kernel (na pasta /boot) atual para o arquivo .config dentro da pasta onde está o kernel, e se executar um make oldconfig, mas cuidado, pois alguns módulos podem mudar de nome de uma versão para outra e isso pode trazer problemas. Enfim, voltando ao contexto original, na tela de configuração do kernel, entre em “General Setup”, na opção “Local Version”, digite um nome para ser adicionado à versão do kernel. Saia da tela e execute o seguinte comando:

# make-kpkg –initrd linux-image

Este comando gerará na pasta /usr/src um arquivo .deb que pode ser instalado através do comando:

# dpkg -i <arquivo>.deb

Eu já tinha seguido esses passos a um tempo atrás para compilar o kernel 2.6.24 no meu Debian, mas hoje me deparei com um problema: eu queria modificar o valor que é adicionado à versão do kernel. Este problema pode ser resolvido apenas movendo a pasta debian de dentro da pasta do kernel que tu estás compilando para um outro nome ou outro lugar. Após isso, basta executar o make-kpkg e o dpkg -i normalmente que tudo deverá transcorrer tranqüilamente.

A boa notícia é que a nova versão do kernel, a versão 2.6.24, corrige este problema! Nesta versão, os caras que mantém o kernel jogaram bastante coisa antiga fora e reescreveram boa parte do código. Agora, as portas USB 1.1 funcionam corretamente e o kernel não desbilita as interrupções, mantendo o teclado funcionando perfeitamente! Sinceramente, fizeram um ótimo trabalho no kernel 2.6.24, até o desempenho da máquina ficou melhor com relação às versões anteriores.

No momento do boot do CD netinst, o Debian pergunta sobre a forma de boot (podendo simplesmente apertar enter e entrar no instalador padrão), digita-se o texto installgui, pressiona-se enter e o instalador irá carregar uma interface gráfica bonitinha e até de certa forma intuitiva para a instalação.

Para se obter uma lista mais completa sobre as formas de boot do netinst, pressiona-se <F1> e, na lista de opções, escolha algo como “formas de boot do instalador” ou algo parecido.

Achei massa, apesar de preferir a interface de instalação padrão. Acredito que funcione também para o businesscard.

O que parecia descontinuado voltou! Já faz um tempo que a Cipsoft, criadora de um dos mais clássicos jogos de MMORPG do mundo – Tibia -, resolveu voltar a distribuir versões do jogo para Linux. É só ir na página oficial do jogo (www.tibia.com), baixar o cliente e descompactar. Aqui deu um problema quando fui executar, abria a janela do jogo, mas a tela ficava toda preta. Isso pode-se resolver facilmente instalando o pacote libosmesa6-dev.

Se tu tem uma distro baseada em Debian, ou o próprio Debian (como eu ^^), abra um terminal, e, como root, execute o seguinte comando:

# apt-get install libosmesa6-dev

Isto instalará pacotes para renderização do mesa, exatamente o que falta para o Tibia rodar. Toque ficha no executável do cliente e divirta-se com a versão Linux deste maravilhoso game. Qualquer dia, coloco aqui um manual para rodar o cliente Tibia pelo Wine e pelo Cedega. ^^

Se tu quiser retirar em cada linha a palavra symbol, os números e os espaços, pode-se gravar uma macro para isso. Sem estar em modo nenhum (<ESC>), aperte em q e mais uma letra, para identificar a macro. Agora, aparecerá a palavra “recording” no rodapé do VIM. Entre no modo de inserção (<INSERT>) e faça para a primeira linha o que tu quer que seja gravado na macro. Quando tiver terminado, saia do modo de inserção e aperte apenas q. Assim, tua macro estará pronta para ser usada. Vá para a próxima linha e aperte @<letra_definida_à_macro>. Por exemplo, se tu definiu a letra ‘a’ para identificar a macro, aperte @a. Todos os passos que tu tinha gravado na macro serão executados nessa linha. Executando isso linha por linha, ficaremos com:

O
VIM
É
MÁGICO

E está feito. Se tu não quiser fazer isso para cada linha (vamos dizer que tu tenha 100 linhas para alterar), tu pode gravar na macro para ele ir para a próxima linha depois de completar tudo. Quando tu for executar a macro, posicione o cursor na primeira linha a ser alterada e digite (sem estar no modo de inserção) 100@<identificador_da_macro>. Assim, o VIM irá chamar 100 vezes tua macro, como foi gravado para ele pular para a próxima linha no final, as 100 linhas são alteradas todas de uma vez.

Mágico!

O interessante é o seguinte: no Debian, o kernel somente desabilita a IRQ #11 quando passo muito tempo sem usar o teclado (questão de uns 15 minutos). Enquanto estou usando, o problema não acontece. No dmesg, só notei uma coisa: ele monta novamente o usb device como se ele tivesse sido desmontado. Acho que aqui está uma grande pista para os desenvolvedores do kernel (ou para eu tentar arrumar!).