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.

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

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

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.

Agora, qualquer pessoa me diria “tu deve estar fazendo algo errado”. Não. Não estou. Entro na linha de comandos do Linux e mando compilar os .java: compila. Acusa alguns warnings, mas compila. E funciona!

Realmente, não entendo o Eclipse. Já arrumei um monte de coisa e nada o faz funcionar. Desisti e estou agora utilizando o gedit mesmo. E, verdade, é muito melhor do que o Eclipse…