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.

Pensei: “e agora?”. Pelo menos eu conseguia bootar o Ubuntu (por causa do time out do grub) e via que o teclado funcionava. Só o grub que não estava gostando dele. Depois de ler alguns tutoriais na internet e pedir alguns conselhos a amigos (valeu César e Rodolfo pela ajuda) descobri que eu poderia arrumar isso habilitando uma opção na minha BIOS. Aqui na minha máquina a opção era “USB keyboard”, mas em algumas máquinas pode ser “USB legacy”. Do estado “disabled” passei para “enabled”, rebootei a máquina e “tchran”! Funcionou! Fica aqui a minha dica para aqueles que tiverem o mesmo tipo de problema que eu e não acharam alguma solução.

A B C

O que o processador realiza é a subtração do conteúdo da posição de memória A pelo conteúdo da posição de memória B, Armazenando esse resultado na posição A. Caso o resultado for negativo, o processador faz um jump para a posição do programa definido em C. Parece coisa de maluco, mas (para quem é nerd o suficiente para tentar =P) funciona.

Pois bem. Fiquei curioso e resolvi desenvolver um emulador. Um pouco mais robusto, faz diferença entre área de código e área de dados, mas funciona. Ainda tem alguns bugs, consigo ler do teclado, imprimir na tela, multiplicar posições, somar, diminuir (já é nativo… =P), setar valores, mover valores… Ainda falta fazer dividir, mas nada que um pouco de tempo livre não resolva. =)

Quem quiser fazer esta experiência, recomendo. É divertido!