comp coop 10

24/09/2009

Interrupção do x86, Minix e, de quebra, uma pitada de estouro de pilha

RussoVaderpor Eduardo Russo

Um dos trabalhos que tivemos (eu, o João Misko e o Rafael Medeiros) que fazer para a disciplina de Sistemas Operacionais foi sobre estouro de pilhas no Minix. Como e onde ocorria, e como era tratado.

O grande salto quântico disso, era entender a tabela de interrupções do x86. Onde fica, para onde aponta e o que faz. Salto dado graças à imensa ajuda do Mestre Jorge Sabaliauskas! Se você não conhece o Jorjão, sinto muito! (more…)

Anúncios

08/07/2009

Tutorial definitivo para recompilar o Minix 3

Filed under: disciplina, tutorial — Tags:, — Russo @ 5:56 pm

ZumbiIcon

por Eduardo Russo

Depois de MUITO apanhar com recompilações e mais recompilações do Minix, com resultados alternados de funcionamento, testes e mais testes com VirtualBox, VMware Fusion (que insiste em dar um kernel panic no Mac OSX cada vez que dou um boot no Minix), Parallels Desktop e Q (versão do QEMU pro OSX), consegui entender o que acontece e como fazer uma compilação do kernel funcionar corretamente! (more…)

10/06/2009

Minix: Alterando o código e recompilando

Filed under: disciplina, tutorial — Tags:, — Russo @ 7:58 pm

ZumbiIconpor Eduardo Russo

Segue um mini tutorial para fazer alterações no código fonte do Minix e recompilar para testar.

O primeiro passo, é editar o código. Para isso, você pode transferir os “.c” via FTP, alterar em outro SO ou, a maneira mais simples, que explicarei aqui, editar no próprio Minix.

No exemplo, vamos alterar a mensagem de boas vindas do Minix.

cd /usr/src/kernel
cp main.c main.c.back
elle main.c

Isso criará um backup do main.c, caso você faça alguma besteira e abrirá o programa Elle (um editor básico, mas que dá pro gasto) com o main.c.

Agora vá na parte que tem a mensagem de boas vindas (Copyright…..) e altere o código.

Aperte CONTROL+W para salvar o arquivo e depois CONTROL+S para sair do Elle.

Agora digite

cd /usr/src
make clean
make install

edit: ou digite:

cd /usr/src/tools/
make hdboot

Agorá vá tomar um café… (edit: só precisa ir tomar um café se você estiver no Bochs) porque demora um bom tempo até ele recompilar.

Depois que terminar a recompilação, basta reiniciar o Minix com

reboot

Ps. Não sei o que acontece, mas as vezes a compilação não faz nada. Acredito nesse momento que seja o espaço setado para usr que influencie isso.

31/05/2009

Minix 3 no Bochs usando Windows XP

Filed under: disciplina, tutorial — Tags:, , — Yuri Duarte Corrêa @ 5:27 pm

Fonte: http://en.wikibooks.org/wiki/Minix_3/Minix_3_on_Bochs

The recipe below was successfully tried with Minix versions 3.1.1, 3.1.2, 3.1.2a. The Bochs ver. 2.2.6 was running under (or over?) Windows XP.It also may work on other operating system that support Bochs Environment.

  • Download a Minix 3 bootable CD ISO image[1]. You’ll download an archive, unpack it – you’ll get the file with name like IDE-3.1.1.iso.
  • Download Bochs – in my case,I have used Bochs 2.2.6 released for Windows XP but should work higher verion[2].
  • Install WinPCap, downloadable from [3].
  • Install Bochs – when asked for options, add DLX Linux.
  • In the directory where the default installed Bochs will be in (C:\Program Files\Bochs-2.2.6) , you’ll find dlxlinux directory.
  • You need to make a copy of dlxlinux in the same parent directory with different name minix3. This new directory will be your Minix OS versions.
  • Go to the new minix3 directory and edit bochsrc.bxrc file.
###############################################################
# bochsrc.txt file for Minix3 disk image.
###############################################################

# how much memory the emulated machine will have
megs: 256

# filename of ROM images
romimage: file=../BIOS-bochs-latest, address=0xe0000
vgaromimage: file=../VGABIOS-lgpl-latest

# what disk images will be used 
floppya: 1_44=floppya.img, status=inserted
floppyb: 1_44=floppyb.img, status=inserted

# hard disk
ata0-slave: type=cdrom, path=IDE-3.1.1.iso, status=inserted

# choose the boot disk.
boot: cdrom

# default config interface is textconfig.
#config_interface: textconfig
#config_interface: wx

#display_library: x
# other choices: win32 sdl wx carbon amigaos beos macintosh nogui rfb term svga

# where do we send log messages?
log: bochsout.txt

# disable the mouse, since DLX is text only
mouse: enabled=0

# ne2k: NE2000 compatible ethernet adapter
ne2k: ioaddr=0x240, irq=9, mac=b0:c4:20:00:00:01, ethmod=win32, ethdev=MYCARD

# enable key mapping, using US layout as default.
#
# NOTE: In Bochs 1.4, keyboard mapping is only 100% implemented on X windows.
# However, the key mapping tables are used in the paste function, so 
# in the Minix3 example I'm enabling keyboard_mapping so that paste 
# will work.  Cut&Paste is currently implemented on win32 and X windows only.

#keyboard_mapping: enabled=1, map=$BXSHARE/keymaps/x11-pc-us.map
#keyboard_mapping: enabled=1, map=$BXSHARE/keymaps/x11-pc-fr.map
#keyboard_mapping: enabled=1, map=$BXSHARE/keymaps/x11-pc-de.map
#keyboard_mapping: enabled=1, map=$BXSHARE/keymaps/x11-pc-es.map
  • Run Boch’s NIC Lister. For a few ordinary Windows XP machines with one network card NIC Lister mentions three interfaces, and some of them usually works.
  • Put the IDE-3.1.1.iso file with Minix 3 bootable CD image into minix3 directory.
  • Edit the run.bat file in the minix3 directory – replace dlxlinux with minix3 on the first line in the path.
# Run.bat
cd "C:\Program Files\Bochs-2.3\minix3"
..\bochs -q -f bochsrc.bxrc
  • Run run.bat – you’ll get Minix 3 booting in the virtual Bochs PC.

Install Minix onto a Virtual Hard Drive

The step below work on any Bochs Environment and doesn’t depend on the operating system

  • Create the file for that drive first. Launch the Disk Image Creation Tool, which is included into Bochs distribution. The interface is very simple – the program just asks a few questions and does the job, but just in case, you’ll wand a hard drive (hd) disk image, of flat (flat) type, sized, for example, 2048 megabytes (2048) – it will actually be 8192 bytes less than that – named hd2gig.img.
  • You’ll need to edit bochsrc.bxrc again. The line in hard disk section, related to disk – if you took the bochsrc.bxrc from dlxlinux, it will contain
# hard disk
"ata0-master: type=disk, path="hd10meg.img", cylinders=306, heads=4, spt=17"

should contain the line, which Disk Image Creation Tool put into clipboard, namely,

# hard disk
"ata0-master: type=disk, path="hd2gig.img", mode=flat, cylinders=4161, heads=16, spt=63"
  • Relaunch Minix booting from cdrom, login as root, run “setup”, which will install Minix on the virtual hard drive. The network will get installed as well.
  • After installation is complete, run “shutdown”, in boot monitor run “off” so Bochs will turn down, and change “boot: cdrom” to “boot: disk”, so you’ll boot next time from virtual disk instead of cdrom.

27/05/2009

Setando o Ambiente do Bochs no Ubuntu

Filed under: disciplina, tutorial — Tags:, , — coop10 @ 6:31 pm

by Duarte.

O primeiro passo a se fazer é baixar a última versão do Bochs no site, então é importante saber que antes de compilá-lo ( com o make ) é preciso setar alguns parâmetros para que seja possível futuramente o debug do kernel.

Instalando o Bochs

Instalando dependências

Antes de compilar o Bochs temos de instalar algumas dependências para que o mesmo funcione e também instalar algum pacote de debug para alguma biblioteca gráfica:

sudo aptitude buil-dep bochs
sudo aptitude install xorg-dev libx11-dev xorg-xserver-dev build-essential

Script para Instalar o Bochs

echo “-> Running Configure with Extra Options:”

./configure –enable-disasm \

–enable-smp \

–enable-debugger \

–enable-new-pit \

–enable-all-optimizations \

–enable-4meg-pages \

–enable-global-pages \

–enable-pae \

–enable-all-optimizations \

–disable-reset-on-triple-fault \

–with-all-libs \

#            –with-x \

–with-x11 \

#            –with-nogui \

if test $? -ne 0

then

echo XXX configured failed

exit 1

fi

echo “-> Running make”

make

if test $? -ne 0

then

echo XXX make failed

exit 1

fi

echo “-> Running make install”

make install

if test $? -ne 0

then

echo XXX make install failed

fi

13/05/2009

Como adicionar System Call no Minix

Filed under: disciplina, tutorial — Tags:, — Yuri Duarte Corrêa @ 10:21 am

Tutorial sobre Minix, feito por um aluno do COOP09. Autorizado.

Yuri

Aeeee galera esperta…

Agora que a gente sabe como compilar uma bosta em C nesse lixo.. e eu entendi o que é system call, vamos brincar de adicionar uma no minix….

Adicionar uma system call no minix (acredito que em outros SOs) passam por dois passos:

– Escrever um system call handler
– Escrever uma user lib

O handler é a função que é chamada em resposta a uma requisicao ao system call… E vale o 1×1, cada system call tem apenas um handler…

A lib empacota os parametros que a system call precisa e chama o handler no server apropriado… o usuario sempre invoca a system call pela lib!

User -> Lib -> Handler

Importante salientar que o handler deve ser associado ao seu correto server, exemplo dado, se a system call atualiza/altera algum arquivo, tem que estar no FS (filesystem) server…

Abaixo segue como criar uma system call que imprime alguma coisa…

1) Os servers estão listados no diretório /usr/src/servers

# cd /usr/src/servers

2) Viram que todos estao separados? O fs é um deles…

3) Instalem os dedos a chatice ta só começando…. seguinte… dentro do diretorio fs, tem dois arquivos, o table.c e o proto.h… blz? Deem um elle neles e olhem a cara dos arquivos.. O table.c contem os index das system calls que serão chamadas em um array, então o que a gente tem que fazer é procurar um espaço não utilizado (no_sys) e adicionar a nossa system call feupuda lá… deem um elle no table.c, e adicionem a sys call desejada exemplo, aconselho vcs a usarem o 64, depois falo pq:

do_printshit,   /*  XX = printshit */     // neste caso antes haveria um “no_sys,    /* XX unused */”
// Decorem o valor que está no XX!!!!

4) ok… fecha o elle (Ctrl+W e depois Esc+X -> yes), agora abre o proto.h com o elle… ele contem todos os prototypes das system calls… entao adicionem a prototype da nova sys call, exemplo:

_PROTOTYPE( int do_printshit, (void) );
// Procurem o comentario com o misc.c e adicionem esse prototype lá, pq a gente vai adicionar a nossa declaracao nesse arquivo, eu to seguindo um tutorial e facilitando pra galera, mas da pra criar em um arquivo separado, é tao simples quanto, é só alterar o Makefile depois…

agora dentro do /fs, acessem o arquivo misc.c, como falei da pra colocar em arquivo separado… e adicionem o codigo:

int do_printshit()
{
printf(“\nMensagem qualquer… welcome to your doom!!\n”);
return (0); //ou return(OK);
}

ok.. next…

5) Blz? Adicionado o prototype e o codigo da syscall voltem para o diretorio dos servers /usr/src/servers… e vamos compilar os servers bonitamente, executem em seguida:

make image // Se der algum erro, olhem o mesmo e vejam se voces alteraram o talbe.c ou o proto.h direito…
make install // Sucesso?

6) Blz… a chatice vai começar agora… ainda tá longe, AUEhiAEhUAehiAHiuhAe…. Decoraram o valor do XX? Não.. putz… olha lá de novo!!! Vamos aprender a chamar o handler direto? Legal né? não… Existe uma system call chamada _syscall que pode ser utilizada para chamar system calls diretamente, olhem a declaracao dela:

PUBLIC int _syscall(int who, int syscallnr, register message *msgptr);

Blz, o who é o server recipiente, no caso o FS, o syscallnr é o numero da system call, no seu caso o XX, e o message é um struct que contem os parametros da syscall que é uma novela.. não vou entrar em detalhes dele pq eu ainda não o entendi direito…

Então pra chamar direto, como a nossa syscall num tem parametros entao o ponteiro do message vai sem nada…

message m;
_syscall(FS,XX,&m);

7) Chato né? pois é… tem mais… antes de mais nada, para usar a message structure nos nossos programas é só dar include na lib.h (#include <lib.h>). Blz? Agora vamos pro segundo passo que é criar a lib… dois arquivos importantes:

/usr/src/include/minix/callnr.h
/usr/include/minix/callnr.h

blz? Adicionem nele um #define com o XX que voces associaram,por exemplo:

#define PRINTSHIT XX

ok? Entenderam pq pedi pra usar o 64…

8) Agora vamos pra parte interessante, vao para o diretorio /usr/src/lib/posix/, nele a gente vai criar a lib em c, neste caso _printshit.c, blz? entao comecem com um elle _printshit.c e escrevam:

#include <lib.h>
#include <unistd.h>
PUBLIC int printshit(void)
{
message m;
return(_syscall(FS,PRINTSHIT,&m));
}
CTRL+W, ESC+X-> Yes…

9) blz… quase lá…mais um pouco… agora no diretorio do posix, vamos adicionar o nome do arquivo que criamos no Makefile.in… elle nele!!!

adicionem algo parecido com:

_pipe.c \    // ja ta la
_printshit.c \   // adicionem igual ta o exemplo no arquvio
_ptrace.c \ // ja ta la tambem…

blz?

agora: entrem com “make Makefile”

voltem para o diretorio /usr/src/ e nele entrem com: “make libraries”

pronto! compilada e instaladas as libs do posix…

10) Acabou? não… Agora a gente vai ter criar uma nova imagem de boot para dar merge nos bins no minix… se nao num vai dar para usar a syscall, vao para /usr/src/tools

make hdboot //blz… entrem com isso e criem a nova imagem de boot
make install //entrem com isso tambem depois do hdboot

Agora gravem, anotem, sei la, o nome da imagem que foi criada, a gente vai bootar com ela da proxima vez, ok? o nome vai ser criado em /boot/image, no meu caso foi criar a 3.1.2ar3, ok?

Agora shutdown no minix!

11) Quando aparecer a entrada para boot (d0p0s0> ) vcs vao associar a imagem criada da seguinte forma:

image=/boot/image/3.1.2ar3 (no meu caso foi esse, vejam o de vcs e adaptem)

depois disso é só bootar normal: “boot” só o boot mesmo…

12) PRONTO!!!! Agora dá pra usar essa merda de syscall…. façam um programinha exemplo igual o que a gente fez do hellworld, saca só:

#include <stdio.h>
int main(void)
{
printshit();
}

13) Vcs vao receber a mensagem que vcs colocaram no printf… assim espero… se nao conseguirem ou encontrarem erros, favor avisar!

Wilson Leão, COOP09.

12/05/2009

Como compilar programa em C no Minix

Filed under: disciplina, tutorial — Tags:, — Yuri Duarte Corrêa @ 8:52 pm

Tutorial sobre Minix, feito por um aluno do COOP09. Autorizado.

Yuri

Galera, segue um micro tutorial de como compilar e ou editar um programa em C nesse troço… espero que seja útil

1) Antes de mais escolha um diretório que seja simpático para ti…

2) Utilizando o comando “elle” crie um arquivo para o seu programinha C…

# elle HellWorld.c  //Semelhante ao vi pra quem ja usou, pra quem nunca viu, ele vai abrir algo parecido com um editor de textos..

3) Agora entre com seu programinha em C…

#include <stdio.h>
int main(void) {
printf(“Hell World!”);
return 0;
}

4) Blz? Agora alguns comandos sapecas do elle…

CTRL+W -> ele escreve o arquivo salvando-o
CTRL+S -> volta para o shell, cuidado com teu arquivo!!!
ESC + X -> Quit? yes….

5) Os comandos de cima já dá pra brincar… Depois de salvo o arquivo, olhem dentro da pasta de voces, confirmem se o .C tá lá…

6) Agora o momento tao esperado:

# cc HellWorld.c -o HellWorld  // o CC é o compilador C do minix (Minix C) e faz parte do ACK (amsterdam compiler kit)
// O -o serve para determinar o nome do arquivo de saida, sem ele, vai sair um inutil “a.out” ….

7) Blz? Agora da uma olhada no diretorio com o ls e ve se o HellWorld foi criado, foi? Entao executa ele…

# ./HellWorld // Esse ./ é pra fazer a magica…

8) Simples né? Não… eu perdi algumas 2 horas pra descobrir essa merda.. Falow people, espero ter sido util….

Wilson Leão, COOP09.

Como editar o código-fonte do Minix pelo Visual Studio (e, de tabela, como acessar o Minix por FTP)

Filed under: disciplina, tutorial — Tags:, — Yuri Duarte Corrêa @ 9:33 am

Tutorial sobre Minix, feito por um aluno do COOP09. Autorizado.

Yuri

Olá,

Não sei se é o caso de vocês, mas eu detesto editores de texto em que eu não posso usar o mouse – e considero um contra-senso que, em pleno 2008, era em que as interfaces de usuário ficam cada vez mais caprichadas e intuitivas, precisemos ficar decorando comandos absolutamente indecifráveis em aplicativos obscuros (cofcof, vi, cofcof).

Portanto, desde que o Kinoshita disse que iríamos ter que editar o código do Minix, eu ando procurando um jeito de passar os arquivos fonte da máquina virtual para o Windows. Além da praticidade de se usar um editor amigável, ainda há a facilidade de se compartilhar o código que foi modificado com colegas – o que é importante quando se considera que não é simples fazer o Minix acessar a internet.

Aliás, foi essa a minha primeira intenção: mandar os arquivos a partir do Minix para meu e-mail, e de lá baixá-los (no fim a solução do FTP acabou sendo superior); mas não consegui por nada no mundo fazer essa porcaria de internet funcionar, nem no Virtual PC, nem no VMWare Player, nem no VMWare Workstation. O máximo que eu consegui, usando este último, foi fazer o Minix ganhar um IP da rede local (usando NAT como tipo de rede virtual) e enxergar o meu Windows – sem acesso à internet, contudo.

Descobri, então, que o Minix já vem com um servidor FTP, e achei que pudesse valer a pena tentar acessá-lo. De fato, funcionou. Para rodar o servidor, é só entrar com esses comandos, que encontrei na internet:

# cat >/etc/rc.daemons
daemonize tcpd telnet in.telnetd
daemonize tcpd ftp in.ftpd
CTRL+D

Isso cria uma entrada no arquivo rc.daemons, o que faz com que o Minix, ao ser iniciado, comece a rodar o servidor FTP (e o Telnet tbm, se alguém quiser – não sei se precisa, mas tava assim no site que eu achei e não to afim de tirar pra testar). Depois disso, é só reiniciar (shutdown -r) e pronto.

De volta ao Windows, é só baixar algum cliente FTP (eu uso o FileZilla), botar o IP que aparece quando o Minix liga, entrar com seu usuário e senha (eu uso root & root; não sei se com senha vazia funciona) e pronto. Depois, baixe todo o conteúdo em /usr/src para algum diretório (o FTP vai começar em /root, então você precisa subir de nível para enxergar o /usr).

No Visual Studio (usei a versão 2008), clique em New->Project From Existing Code, e indique o diretório onde você baixou os fontes. Selecione Visual C++ como o tipo de projeto, e marque “Use external build system”. Ele vai reconhecer todos os arquivos e organiza-los hierarquicamente.

Pronto! Agora você pode ler todo o código fonte do Minix, se aproveitando de coisas como “Go to Definition” e outras perfumarias. Eu ainda não consegui fazer ele compilar o código (o Visual Studio vem com uma ferramente chamada nmake que simula o make do GNU, mas não funciona direito nesse caso), de modo que para testar se o seu programa não tem erros de sintaxe você precisa fazer o upload e dar o make no Minix (aliás, uma dica: caso vocês mudem alguma coisa e não estejam vendo nenhum reflexo, experimentem dar “make world” em /usr. Isso recompila e reinstala tudo). Meio chato, mas pelo menos não precisa ficar mexendo naquele lixo de vi.. hahaha

Bom, é isso. Me custou algum tempo, então achei legal compartilhar as instruções. Espero que seja útil para alguém!

Pedro d’Aquino, COOP09.

Blog no WordPress.com.