Primeiramente, o que é VFS? VFS é Virtual File System. É uma camada que existe em muitos sistemas operacionais e também no Minix, que cuida da parte comunicação com o File System. O mesmo foi desenvolvido pelo Balázs Gerófi como tese de Mestrado na universidade de Amsterdam com nome de “Design and implementation of the MINIX Virtual File system“.

Mas por que se comunicar com o servidor VFS? Por que adicionar algo nele? Bom, se você está trabalhando em baixo nível e quer por exemplo acessar diretamente os INODES por algum motivo, você deve inicialmente se comunicar com o servidor VFS. Para realizar a comunicação é simples, mas vamos supor que você queira um método especifico que o mesmo não possue, então você deve cria-lo.

Como fazer isso?

Inicialmente você deve editar o “/usr/src/include/minix/callnr.h”. Adicione logo abaixo a linha “#define GETPGRP 63″ o seguinte:

Em seguida você deve modificar o servidor VFS e adicionar o que você quer que faça quando a mesma for chamada. Edite inicialmente o “/usr/src/servers/vfs/table.c”. Você deve pegar a linha que possui no_sys, /* 64 = unused */
E alterar para:

Este será o método chamado quando a syscall de número 64 for executada.

Após isso você deve alterar o “/usr/src/servers/vfs/proto.h” que é onde estão definidos os métodos. Adicione o seguinte:

Então você deve criar o método propriamente dito dentro do “/usr/src/servers/vfs/read.c” (ao menos eu fiz nesse arquivo). Adicione o seguinte código:

Mas como executar? E ver isso tudo funcionando? Como compilar?
Inicialmente acesse “/usr/src/tools/” e execute:

$ make libraries

(Este pode ser um processo demorado)

Continue em “/usr/src/tools” e execute:

$ make hdboot

Reinicie.

Como testar e ver se está funcionando? Crie um arquivo no seu “/root” com o seguinte conteúdo:

O que isso é pra fazer? Fazer uma syscall no método 64, passar por mensagem o número 2, então o do_TESTCALL recebe o parametro e imprime o mesmo. Bem inutil, mas isto é pra demonstrar como criar métodos dentro do servidor VFS.

Exemplo dos códigos adicionados no servidor VFS

Criando uma biblioteca do sistema no Minix.

Atenciosamente,
Matheus

PS: É um exemplo bobo, mas é para demonstrar como adicionar métodos ao servidor VFS. Provavelmente nos próximos dias publicarei um exemplo, mais real.

NOME.h

_PROTOTYPE(int NOME_DA_FUNCAO, (int PARAM));

Depois disso acesse /usr/src/lib/other e crie o arquivo com a seguinte estrutura:

NOME.c

#include<lib.h>
#include<unistd.h>
#include<stdio.h>

PUBLIC int NOME_DA_FUNCAO(int PARAM) {
// O QUE FAZ?
}

Edite o arquivo Makefile.in no mesmo diretorio (/usr/src/lib/other). Adicione o nome do seu arquivo a lista em ordem alfabetica.

O que fazer agora?

Regere o arquivo Makefile

$ cd /usr/src/lib/other/
$ make Makefile

Gere as bibliotecas: (processo um pouco lento dependendo da maquina)

$ cd /usr/src/tools
$ make libraries

Quando finalizar sem erros “compile” o sistema:

$ cd /usr/src/tools
$ make hdboot

Ele substituira os arquivos do boot automaticamente, para ter as atualizacoes, reiniciar o sistema.

Como testar? Crie um arquivo no /

testTest.c

#include <stdio.h>
#include <unistd.h>
#include <lib.h>
#include <fcntl.h>
#include <NOME.h>

int main(int argc, char *argv[]) {
NOME_DA_FUNCAO(PARAM);
}

Agora voce pode criar suas proprias bibliotecas do sistema no Minix.

Exemplo de biblioteca criada pelo usuario para o Minix

Atenciosamente,
Matheus

Nos últimos dias uma amiga pediu ajuda para resolver dois exercícios em C++ que o professor dela havia passado. O enunciado dos mesmo são:

1. Faça um programa que leia um numero não determinado de valores inteiros e positivos. Para cada valor lido: se o numero for par, verificar quantos divisores possui e escrever esta informação. Se for impar e menor que 12, escrever o seu fatorial. Se for impar e maior que 12, escrever a soma dos números de 1 até ele.

Resolução C++ do exercicio 1.

2. Escrever um programa que leia valores, um de cada vez, e conta quantos deles estão em cada um dos intervalos: [0,25], [25, 50], [50, 75] e [75,100].

Resolução C++ do exercicio 2

Matheus

PS: Pra mim é C mas como só ajudei ela não entrei no mérito dessa questão.

Neste post vou publicar uma árvore B em C++ desenvolvida por mim e pelo meu colega Olav, como trabalho da aula de estrutura de dados. A mesma le um arquivo de ceps e insere os mesmos em uma árvore e calcula o tempo de inserção para cada item. Infelizmente, me parece que o medidor de tempo não está correto, porém com a árvore está.

Caso você descubra algo errado por favor, reporte-me

Árvore B

Matheus Bratfisch

Para não perder o costume, irei postar outro exercicio resolvido em uma aula. Dessa vez o exercicio é o seguinte:
- Implemenetar o sistema de contabilidade de um mafioso. (outros detalhes continue lendo o post)

O enunciado do mesmo se encontra no “read the rest of this entry” para não deixar o post muito extenso devido ao longo enunciado.

A resolução do mesmo você pode baixar aqui.

Você é um Mafioso informatizado.
Você vai criar um sistema para gerenciar os seus débitos e também as pessoas que devem a você.
Este sistema será baseado em duas listas encadeadas:

(Imagem de exemplo)

* Para isso você vai fazer um programa que manipula mais de uma lista;

* o programa fará isto com um único conjunto de funções e passagem das diversas listas como parâmetros;
* como aplicação imaginemos um sistema de contabilidade simples;
* você vai ter um Plano de Contas constituído por duas listas: débitos e créditos;
* o mesmo conjunto de funções (que você já implementou) vai poder ser utilizado para isso: você somente precisa ampliar o conjunto de parâmetros da função para passar por referência também a lista que você quer alterar.

A passagem de parâmetro da lista deve ser por referência porque você deseja que as alterações sejam persistentes.

Cada lista de débitos ou créditos é constituída por lançamentos. Cada lançamento possui:

* um valor real (positivo);
* um nome. Por exemplo, “Pagar proteção à Mafia”

Estrutura:
tipo tLançamento {
caracter *nome;
real valor;
};

A lista encadeada que conterá os lançamentos terá um elemento de lista definido da seguinte forma:
Estrutura:
tipo tLista {
tLancamento* info;
tLista* proximo;
};
A cabeça de lista de cada lista será uma variável global contendo uma estrutura como abaixo:
tipo cLista {
tLista* lista;
inteiro ultimo;
};

No programa principal você vai definir se vai realizar uma operação de débito ou de crédito e vai chamar as operações sobre listas necessárias, passando a lista correta como parâmetro (por referência) para a função que realiza a operação.

Além das operações básicas que a lIsta vai oferecer, você deve implementar uma operação adicional: totalização. Essa operação funciona assim:

* percorre a lista, escrevendo o nome e o valor correspondente a cada item (débito ou crédito)
* soma o valor em uma variável auxiliar
* escreve ao final o total de débitos ou de créditos, dependendo de qual lista você mandou totalizar.

Como ainda não produzi nada muito bom hoje em casa (no lab produzi algo relaciona a xml-rpc que pretendo postar em breve), resolvi postar mais um dos 198578951 exercicios que estou tendo que fazer para estrutura de dados. O Exercicio de hoje é nada mais nada menos que uma implementação de uma Lista com Ponteiros, ou seja, ela não tem limite de elementos (é claro, se a memoria for infinita).

Como no exercicio anterior, o enunciado fica para a pagina inteira pois é muito grande.

O exercicio resolvido você encontra aqui.

Uma lista ordenada pode conter Strings de qualquer comprimento < 10000;
• esta lista tem um número de elementos máximo fixo (100) e é implementada como um vetor de ponteiros para Strings;
– utilize as rotinas de lista com vetor que você implementou para a agenda.
• Um novo String é lido primeiramente para dentro de uma variável auxiliar qualquer;
– então é alocada memória para exatamente o seu tamanho e ele é copiado para esta área. Para copiar um String utilize strcpy();
– por fim um lugar na lista é encontrado para ele. A posição escolhida do vetor de ponteiros da lista é instanciada através da atualização dos valores do ponteiro da posição do String na lista com o endereço do string.

Pseudo-código:
constantes MAXLISTA = 100;
tipo tLista {
// Vetor de ponteiros para caracter.
caracter *dados[MAXLISTA];
inteiro último;
};

• Importante: observe que criando uma variável do tipo tLista você não vai estar alocando memória para os strings a serem lidos, apenas para os ponteiros para eles.
Para verificar o comprimento de um String:
– utilize a função strlen();
– esta função devolve o comprimento (em caracteres imprimíveis) de um string.
– Protótipo: int strlen(char *p);

#include
#include
#include
char p[90] = “Carro”;
main() {
printf(“%i”, strlen(p));
}

• Imprime: 5
• Para copiar um String:
– utilize a função strcpy();
– esta função copia o conteúdo de um string (dado por um apontador) para a posição de memória dada por outro apontador.
– Protótipo: char *strcpy(char *destino, char *fonte);

#include
#include
#include
char p[90] = “Carro”;
char lata[20];
main() {
strcpy(lata, p));
printf(“s%”, lata);
}
• Imprime: Carro

Detalhes:

• Como você não sabe o comprimento do String que o usuário vai digitar, use primeiro uma variável auxiliar grande (10000 posições) para guardar o que foi
digitado;
• todas as funções de lista ordenada implementadas anteriormente devem ser reimplementadas para utilizar estes Strings;
• para a leitura de um String utilize scanf(“%s”, entrada).

Para ver o enunciado inteiro continue lendo (enunciado grande).

Para baixar o arquivo, clique aqui!

Reimplemente o seu programa de pilha com vetor de números inteiros usando como TOPO um ponteiro para inteiro, que você incrementa, decrementa e testa
para saber se a pilha está cheia ou vazia;
• para resolver:
– modifique a estrutura tPilha da seguinte forma:
constantes MAXPILHA = 100;
tipo tPilha {
inteiro dados[MAXPILHA];
inteiro *topo;
};

• Modifique os algoritmos de manipulação da pilha de forma que se utilize ponteiros para inteiro para referenciar os elementos da pilha.
• Exemplo:
Inteiro FUNÇÃO empilha(inteiro dado)
início
SE (pilhaCheia) ENTÃO
RETORNE(ErroPilhaCheia)
SENÃO
// Se houver espaço, incremento o
// ponteiro topo e faço o valor
// apontado por topo receber o novo
// dado.
aPilha.topo <- aPilha.topo + 1;
*(aPilha.topo) <- dado;
RETORNE(aPilha.topo);
FIM SE
fim;

• Lembre-se de adaptar a inicialização da pilha e também os testes de pilha cheia e vazia. Exemplos:

FUNÇÃO inicializaPilha()
início
// Fazemos o topo apontar para um endereço de memória
// anterior ao início do vetor dados para simbolizar
// que a pilha está vazia.
aPilha.topo <- aPilha.dados - 1;
fim;
Booleano FUNÇÃO pilhaVazia()
início
SE (aPilha.topo < aPilha.dados) ENTÃO
// O topo está apontando para um endereço de
// memória anterior ao próprio início da
// pilha. Segundo a nossa definição, isto
// significa que a pilha está vazia.
RETORNE(Verdadeiro)
SENÃO
RETORNE(Falso);
fim;

Hoje pretendia instalar o netbeans 6.5.1 no Ubuntu 64 bits, baixei a versão que eu queria (C/C++) no site do netbeans. Tentava instalar o netbeans com o comando:

$ ./netbeans-6.5.1-ml-cpp-linux.sh

(PS: Tornei o mesmo executavel antes, com o comando $ chmod +x netbeans-6.5.1-ml-cpp-linux.sh)

Recebia a seguinte resposta:

x-warrior@x-warrior-desktop:~/Desktop$ ./netbeans-6.5.1-ml-cpp-linux.sh
Configuring the installer…
Searching for JVM on the system…
Extracting installation data…
Running the installer wizard…
x-warrior@x-warrior-desktop:~/Desktop$

Porém a parte grafíca não acontecia. Fui olhar o log da seguinte maneira:

$ sh netbeans-6.5.1-ml-cpp-linux.sh –verbose –output out.txt

Analisando o arquivo out.txt pude ver o seguinte erro:

[2009-04-27 20:56:18.173]: at org.netbeans.installer.Installer.main(Installer.java:78)
[2009-04-27 20:56:18.174]: … show message dialog
[2009-04-27 20:56:18.174]: title: Critical Error
[2009-04-27 20:56:18.174]: message: An unexpected exception happened in thread main
[2009-04-27 20:56:18.174]:
[2009-04-27 20:56:18.174]: Exception:
[2009-04-27 20:56:18.174]: java.lang.NoClassDefFoundError:
[2009-04-27 20:56:18.175]: Could not initialize class java.awt.Toolkit

Infelizmente não sabia como corrigi-lo. Pesquisei um pouco e não achei nada que funcionasse. Então tive a brilhante idéia de instalar pelo synaptic. Instalei o netbeans que estava lá, tudo ocorreu normalmente. Executei o mesmo e fui criar um novo projeto, me deparo que a versão instalada era a para Java. Me decepcionei, afinal precisava mesmo da versão para C/C++. Quando fiz a instalação pelo synaptic percebi que existiam muitas dependencias, tentei instalar novamente a versão para C e vua-la. Consegui instalar a mesma. (Meio na gambiarra eu sei, afinal fiquei com 2 versões de netbeans uma para C e outra para Java, mas sem problemas já que eu utilizo as duas.)

Então caso você queira instalar a versão para C/C++, instale a versão de Java, ou suas dependencias somente e em seguida instale o para C/C++ que tudo vai ocorrer bem.

Ah, para um melhor entendimento editei o menu (Botao direito sobre Applications – edit menu), ele é muito intuitivo então não vou entrar em mais detalhes. Mas no mesmo editei os Netbeans 6.5 e 6.5.1 para Netbeans 6.5 (Java) e Netbeans 6.5.1 (C/C++). Assim não corro o problema de esquecer e abrir a versão errada perdendo tempo.

Espero que essa gambiarra dica ajude vocês.

Abraços,
Matheus

PS: Se alguem tiver a solução decente para conseguir instalar o Netbeans me avise que eu posto aqui. Ou caso eu descubra, postarei também.

Como estou tendo aula de estrutura de dados estou tentando colocar aqui, alguns dos conceitos que aprendemos em sala, junto ao seu exercicio e uma implementação de um exercicio (desenvolvido rapidamente, muitas vezes). A estrutura apresentada hoje é Lista, uma estrutura de dados linear. Existe também a lista ligada, ou encadeada que também é conhecida por linear e dinamica (fica pra outro post) e a lista duplamente ligada, ou duplamente encadeada (fica pra outro post também). A pilha e a fila são implementações especiais de listas. A Lista, não possue restrições como suas implementações especiais, e pode receber elementos em qualquer posição, remover de qualquer posição, remover especifico, adicionar em ordem entre outras.

O enunciado do exercicio que foi proposto para lista é o seguinte:

1. Crie o seu tipo de dados tLista em um headerfile;
2. esta deverá ser uma lista de elementos do tipo tAgenda;
3. O tipo tAgenda é um tipo que representa um nome de 30 posições e um número de telefone;
4. crie uma função maior(a,b) que compare os nomes de duas entradas;
5. programe todas as funções documentando cada função, inclusive com dicionário de dados;
6. crie um programa principal que execute todas as funções de lista a partir de um menu. A função procurar específico deverá basear-se no nome em uma Agenda;
7. além dessas funções, o programa deverá ser capaz de listar a lista em ordem alfabética.

Resolução do mesmo aqui.

Até mais,
Matheus

Como estou tendo aula de estrutura de dados estou tentando colocar aqui, alguns dos conceitos que aprendemos em sala, junto ao seu exercicio e uma implementação de um exercicio (desenvolvido rapidamente, muitas vezes). A estrutura apresentada hoje é Fila, uma estrutura de dados baseada no principio FIFO (first in, first out) ou seja, primeiro a entrar é o primeiro a sair. Ela, como a pilha possui duas funções básicas, que é adiciona e remove. Uma adicionando no fim, como uma fila (sem furos, é claro!) e a outra retirando do inicio.

Já faz alguns dias que resolvemos esse exercicio e pra ser sincero não tenho certeza se estou postando a ultima versão que tenho do mesmo, mas acredito que sim. O enunciado do exercicio resolvido foi o seguinte:

* Implemente todas as operações vistas sobre fila;
* implemente um programa principal que utilize a fila através de um menu com os seguintes itens: enfileirar, desenfileirar, limpar, mostrar fila, sair do programa. Use a estrutura de programação switch do “C” para isto;
* a fila possuirá tamanho máximo 100, definido como uma constante chamada MAXFILA. Utilize esta constante para a definição da estrutura de dados que será a fila;
* a fila será referenciada por uma variável global;
* para implementar a estrutura de dados defina um tipo elementoDaFila que será char[40] e defina a sua fila como um vetor de 100 elementoDaFila .

Aqui está a implementação da mesma que acredito ser a ultima.

Abraços,
Matheus

PS: Com o tempo eu pretendo (não sei se consigo) fazer algumas mudanças nas mesmas assim que for aprendendo novas tecnicas e conceitos relacionados ao assunto, mas como a faculdade ta muito corrida não sei se vai ser possivel.