E... Aqui estamos (estou?) com mais um relato sobre duas atividades envolvendo o Projeto Fedora! Ele contempla, respectivamente, os Install Fests ocorridos na UNESP de Rio Claro/SP e na UNICAMP. Foram atividades que envolveram diversas pessoas, tiveram vitórias e derrotas, alegrias e tristezas, mas acima de tudo um sentimento de impotência (principalmente no Install Fest ocorrido na UNICAMP) em relação às novas "tecnologias" de boot, principalemente ao Secure Boot.

Install Fest: missão UNESP de Rio Claro/SP

Este foi o Install Fest mais tranquilo. Ele começou a ser organizado logo depois da minha participação na Semana da Computação da UNESP de Rio Claro, e a intenção inicial era realizá-lo no dia da matrícula dos alunos ingressantes na Universidade. No final das contas, decidimos postergar a data, e isso foi uma boa escolha.

O Install Fest aconteceu no dia 06 de março de 2013, em um auditório da Biblioteca do campus, e começou com uma palestra minha sobre o Projeto Fedora. Foi basicamente a mesma palestra que eu havia apresentado na Semana da Computação, mas de uma maneira mais sucinta porque tínhamos pouco tempo. Creio que a palestra foi bem recebida, porque o público demonstrou interesse em contribuir com o Projeto Fedora depois que eu expliquei os meios para isso :-). Além disso, apesar do número pequeno de pessoas (aproximadamente 12 participantes), todos estavam bastante interessados no conteúdo, o que é uma motivação extra!

Bem, após a palestra era hora de começar a instalar os sistemas. Levei vários DVDs do Fedora, em basicamente 2 versões: LiveDVDs, que permitem o boot e a utilização de um sistema Fedora sem a necessidade de instalar nada na máquina, e InstallDVDs, que não oferecem a opção de "experimentar" o sistema, mas já possuem todos os pacotes necessários para fazer uma instalação completa. Expliquei a todos os presentes algumas regras básicas de todo Install Fest: é preciso reparticionar o disco rígido caso se queira manter o Microsoft (R) Windows (R), quem organiza o Install Fest não pode assumir responsabilidade por nenhuma falha na instalação (apesar de elas serem raras), e também não pode assumir responsabilidade caso o usuário torne-se viciado no GNU/Linux :-). Dito isso, começamos a colocar as mãos na GNU/massa.

O primeiro desafio (e, até então, único!) dos Install Fests recentes é imposto pelos próprios fabricantes de notebooks. Um disco rígido que ainda utilize MBR (a maioria) suporta apenas 4 partições primárias. Antigamente, os fabricantes criavam apenas uma partição para o Microsoft (R) Windows (R), e às vezes chegavam a criar outra partição de "recuperação", mas paravam por aí. Atualmente, não é raro encontrar computadores com 4 partições primárias já criadas. Eu inclusive já cheguei a ver notebooks com discos de 1 TB com uma partição primária de pouco mais de 1 MB! É uma prática totalmente absurda, e a meu ver é feita com má-fé, visando dificultar a instalação de outros sistemas operacionais. Além disso, pra piorar ainda mais, alguns fabricantes (HP me vem à cabeça, mas existem outros) dão um jeito de invalidar a garantia caso o esquema de particionamento seja alterado!!!

Felizmente, vários computadores no Install Fest possuíam apenas 3 partições (ou até menos!), e aqueles que possuíam 4 partições ou usavam um outro boot sector (chamado GPT), ou já estavam fora da garantia do fabricante e podiam ter seus esquemas de particionamento alterados. O próprio Microsoft (R) Windows (R), a partir da versão 7 (se não me engano), oferece uma ferramenta específica para redimensionar e reparticionar o disco, portanto essa primeira etapa foi concluída com sucesso em todas as máquinas (por favor, se você participou do Install Fest e se lembra de alguma máquina na qual não foi possível efetuar o reparticionamento, por favor contate-me <about> para que eu corrija o post!).

Depois de reparticionar, era hora de começar a instalação. Quase todos preferiram utilizar o InstallDVD, porque a instalação pela internet iria demorar muito. Após o boot, deparamo-nos com a interface do instalador do Fedora 18. Depois de ter lido diversas críticas sobre ele, pude finalmente confirmar que, infelizmente, quase todas condizem. Confesso que fiquei confuso no início, principalmente na tela de particionamento e seleção de disco, que não é nem um pouco intuitiva. Sei que o instalador foi reescrito, e que ele foi um dos principais motivos do atraso no lançamento do Fedora 18, então espero muito que as melhorias para o Fedora 19 contemplem, principalmente, essa parte de interface com o usuário. Após apanhar um pouco, acabei me acostumando com ele e as outras instalações foram mais tranquilas.

Conforme as instalações foram acabando, os sistemas começaram a ser configurados. Se minha memória não falha, todos optaram por instalar o GNOME 3, que é o desktop padrão do Fedora 18. Eu particularmente não gosto dele, e também tive algumas dificuldades (principalmente ao tentar encontrar modos de alterar opções mais avançadas), mas algumas pessoas gostaram do visual.

No final, esqueci de contar quantas máquinas foram instaladas, mas creio que chegamos perto de 11. Todas as instalações foram bem sucedidas, até onde minha memória alcança :-). E novamente eu fiquei bastante satisfeito com minha ida à UNESP de Rio Claro!

Entretanto, nuvens negras estavam se aproximando, e minha alegria duraria pouco...

Install Fest: missão UNICAMP

Há alguns anos começaram a surgir notícias sobre um novo sistema que substituiria a BIOS, permitindo muito mais flexibilidade durante o boot e inclusive adicionando camadas de segurança que protegeriam o usuário de vírus e outras ameaças. Esse sistema chama-se UEFI (e uma das tais "camadas de segurança" chama-se Secure Boot), e no ano passado ele ganhou muita notoriedade porque a Microsoft (R) anunciou que seu então novo sistema, o Windows (R) 8, só poderia ser utilizado em máquinas com UEFI. Isso causou uma corrida dos fabricantes de computador para adaptar-se a esse novo modelo (e ganhar o famigerado selo de compatibilidade da Microsoft (R)), e gerou incoformismo em boa parte das comunidades envolvidas com Software Livre e/ou Open Source.

Resumindo, o grande problema desse novo esquema é a necessidade de uma chave criptográfica assinada por uma autoridade certificadora para que o sistema operacional seja iniciado. Essa é a segurança que o Secure Boot provê, e o único jeito de obter uma chave assinada é... (tambores)... pagando à Microsoft (R)!

Até onde eu sei, o Microsoft (R) Windows (R) 8 não funciona caso o Secure Boot esteja desabilitado (um meio perfeitamente válido de instalar uma distribuição GNU/Linux que não possui a tal chave criptográfica), então a distribuição é obrigada a compactuar com esse esquema caso queira oferecer a opção de dual-boot ao usuário. E atualmente, as duas únicas distribuições que oferecem isso são o Fedora e o Ubuntu.

Bem, depois dessa sucinta explicação, começa aqui meu relato sobre o que aconteceu no Install Fest. No dia 13 de março de 2013, quarta-feira, nos reunimos no Instituto de Computação da UNICAMP para realizarmos a instalação de distribuições GNU/Linux. Novamente, eu levei vários DVDs do Fedora para serem utilizados pelos alunos ingressantes nos cursos de Ciência e Engenharia de Computação. Dessa vez não houve palestra introdutória sobre o Projeto Fedora, mas eu resolvi pegar 10 minutos e explicar as "regras" de um Install Fest. Também comentei sobre a má prática que algumas fabricantes de notebooks têm quando decidem entregar um disco rígido todo particionado e sem a possibilidade de adição de novas partições primárias. Dito isso, começamos a instalar.

Infelizmente, devido a diversos fatores como inexperiência, tempo curto para organização do evento, e erro na estimativa de quantas pessoas iriam ao evento, acabamos ficando com muita gente pra instalar e pouca gente pra ajudar. Não chegamos a fazer uma contagem oficial, mas eu suponho que pelo menos 20 pessoas estavam na sala querendo instalar o Fedora. E a grande maioria delas estava com notebooks novos, com Microsoft (R) Windows (R) 8, i.e., com UEFI e Secure Boot habilitados.

Conforme íamos reparticionando os discos e bootando os DVDs do Fedora, começamos a perceber que havia algo errado. Depois de terminar a instalação em algumas máquinas, notávamos que o sistema não iniciava. O que tínhamos que fazer, em alguns casos, era desabilitar o Secure Boot (mesmo assim, sem sucesso em alguns casos). E depois disso, o Fedora finalmente era iniciado, mas o Microsoft (R) Windows (R) 8 não aparecia na lista de sistemas operacionais do GRUB! Ou seja, era impossível fazer com que os dois sistemas convivessem na mesma máquina.

Tivemos alguns casos um pouco mais graves, mas que no fim foram resolvidos. E antes que você me pergunte qual foi a solução, eu respondo: reabilitamos o Secure Boot, e praticamente desfizemos a instalação do Fedora. Ou seja, a esmagadora maioria dos alunos presentes no Install Fest voltou pra casa com uma máquina sem Fedora ou qualquer outra distro GNU/Linux. Eu pessoalmente vi apenas 2 instalações bem sucedidas, apesar de que depois do Install Fest fiquei sabendo de mais.

Saí do evento bastante chateado, achando que a culpa havia sido nossa, e que os alunos nunca mais iriam querer instalar GNU/Linux nas suas máquinas. Mas depois de um tempo, coloquei as idéias em ordem e resolvi escrever este post. Não estou eximindo ninguém da culpa, creio que devíamos ter planejado o Install Fest um pouco melhor, e com certeza aprendemos com os erros que cometemos. Mas acho muito importante apontar alguns dedos e dizer o que realmente aconteceu.

Conclusões

A conclusão principal não poderia ser outra. É preciso tomar muito cuidado com essas novas tecnologias de boot. Quando for comprar uma máquina nova, é preciso prestar muita atenção a isso, pois essas novas tecnologias nada mais são do que armadilhas para tirar a sua liberdade de escolher o que quer executar na sua máquina. É preciso lutar contra essas imposições que as empresas fazem (não seja inocente pensando que é só a Microsoft (R) que está por trás disso...), e é preciso tomar conta da sua liberdade. Se quiser demonstrar ainda mais seu apoio contra essas imposições (e entender mais do porquê delas existirem), clique aqui e leia a página da Free Software Foundation sobre o assunto (e assine a petição também!).

Conclusões secundárias: um Install Fest (ou qualquer evento, na verdade) precisa ser organizado com antecedência, e precisa ter bastante gente disposta a ajudar nas instalações. Só assim as coisas fluem.

Agradecimentos

Não posso deixar de agradecer o Ricardo Panaggio por me ajudar indo até a UNESP de Rio Claro comigo! Ele também ajudou bastante no Install Fest da UNICAMP.

Também gostaria de agradecer ao Marcel Godoy e ao Centro Acadêmico da Computação da UNESP de Rio Claro pela organização e divulgação do Install Fest lá. Muito obrigado!

O Install Fest da UNICAMP só foi possível com a ajuda do Grupo Pró-Software Livre da UNICAMP, em especial ao Gabriel Krisman. O Ivan S. Freitas e o Raniere Gaia Silva também ajudaram no apoio logístico do Install Fest.

Por fim, gostaria de agradecer à comunidade Fedora pelo apoio com os DVDs. Obrigado a todos!


Bye bye, Juvia!


Tags:

Once upon a time, there was a guy who cared about what other people could say about what he was writing on his blog. Well, like all fairy tales, this one also has a happy ending!

In case you didn't make the connection, the "guy" is me :-). And also in case you didn't notice: my blog does not have a comment system anymore. My reasoning for that is simple, and I can make a small list with the major points that made me take this decision:

  1. Juvia (the comment system I was using) is written in Ruby, which in itself is enough to drop it entirely (I really don't understand how it is modeled, and I spent quite some time trying to figure out how to hack it);
  2. I had to run Passenger on my Apache, which was eating lots of RAM (I only have 2GB of RAM in my personal home server, which is where I was running Juvia);
  3. I had to run MySQL in order to store the comments (the other option was PostgreSQL), which was also eating lots of RAM;
  4. I want to use my personal home server for other things :-).

I probably could list a few more reasons, but I think you get the picture. Before dropping the comment system, I spent some days thinking about whether the blog readers would like the decision or not, but after all this time I came up with this: if you, dear reader, want to send me your opinion about what I write here, you can easily send me an e-mail (see the "About" page for my address), and I will happily reply to whatever you have to say. And if I notice that the blog is losing by not having interesting discussions, I can easily bring the comment system back online (though I'd like to find another solution that consumes less memory).

Anyway, that's it. I'll make another post about something interesting soon, I promise. Stay tunned!


This will probably be one of those controversial posts, but I really cannot just be silent about a behaviour that I am constantly seeing around me.

Since my childhood, I am fascinated by the power of the words. I always liked reading a lot, and despite not knowing the grammar rules (either in pt_BR or en_US, the former being my native language, the latter being the only idiom I can consider myself fluent in), I am deeply interested in what words (and their infinite meanings) can do to us. (If you can read in portuguese, and if you also like to study or admire in this subject, I strongly recommend a romance by José Saramago called "O Homem Duplicado"). So now, what I am seeing everywhere is that people are being as careless as ever with words, their meanings, and specially their implications.

The problem I am seeing, and it is a serious problem in my opinion, is the constant use of the term "free software" when "open source" should be used. This is obviously not a recent problem, and I really cannot recall when was the first time I noticed this happening. But maybe because I am much more involved with (real) free software movements now, I have the strong impression that this "confusion" is starting to grow out of control. So here I am, trying to convince some people to be a little more coherent.

When you create a group to talk about free software, or when you join a group whose goal is to promote free software ideas, you should really do that. First of all, you should understand what free software is about. It is not about open source, for starters. It is also a political movement, not only a technical one.

I was part of a group in my former university which had "Free Software" in its name. For a long time, I believed the group really was about free software, even after receiving e-mails with heavy negative critics about my opinions when I defended something related to the free software ideology (e.g., when I suggested that we should not have a Facebook page, which had been created for the group by one of its members). Well, when I really could not hide the truth from myself anymore, I packed my things and left the group (this was actually the start of a new free software group that I founded with other friends in Brazil).

I also like a lot to go to events. And not only because of the presentations, but mostly because I really like to talk to people. Brazilians are fortunately very warm and talkative, so events here are really a fertile soil for my social skills :-). However, even when the event has "free software" in its name and description, it is very hard to find someone who really understands the philosophy behind the term. And I'm not just talking about the attendees: the event staff is also usually ignorant (and prefer to remain like this)! I feel really depressed when I start to defend the (real) free software, and people start looking at me and saying "You're radical.". It's like going in a "Debugger Conference" and feel ridicularized when you start talking about GDB! I cannot understand this...

But the worst part of all this is that newcomers are learning that "free software" is "Linux", or something which is not free software. This is definitely not a good thing, because people should be aware that the world is not just about software development: there are serious issues, including privacy and freedom menaces by Facebook/Google/Apple/etc, which we should fight against. Free software is about that as well. Awareness should be raised, actions should be taken, and people should refuse those impositions.

So, to finish what I want to say, if you do not consider yourself a free software activist, please consider becoming one. And if, after giving it a thought, you decided that you really do not want to be a free software activist, then do not use the name "free software" in your event/group/whatever, unless you really intend to talk about it and not open source.. In other words, if you don't want to help, please don't spread confusion.


Olá a todos!

Finalmente consegui um pouco de tempo na minha agenda, e resolvi escrever no blog para anunciar a criação do grupo LibrePlanet São Paulo!

O que é o LibrePlanet

O projeto LibrePlanet teve início em 2006, durante a reunião de membros da FSF (a Free Software Foundation). Ele foi criado para ajudar a organizar maneiras de levar o movimento de Software Livre ao conhecimento da população em geral.

Os grupos são organizados geograficamente, e cada um é responsável por definir metas e estratégias visando fomentar o Software Livre na região. É importante deixar claro: o objetivo é trabalhar em prol do Software Livre, e não do open source. Para saber mais a respeito da definição de Software Livre, recomendo que leia este artigo.

O surgimento do LibrePlanet São Paulo

Essa história é um pouco longa, mas vou tentar resumir :-).

Tudo começou quando eu, Ricardo Panaggio, Ivan S. Freitas e Raniere Gaia Silva começamos a trocar alguns e-mails sobre assuntos como privacidade, software livre, soluções e serviços livres, etc. Eu e o Panaggio já estávamos nos sentindo muito insatisfeitos com os rumos que um grupo local, teoricamente "pró software livre", estava tomando (como quase tudo hoje em dia, o nome "software livre" está lá simplesmente porque ninguém se tocou de que devia ser "open source" ainda...). E essa insatisfação já vinha nos fazendo querer criar um novo grupo, fiel à ideologia do Software Livre, no qual pudéssemos dar nossas opiniões sem medo de sermos esmagados por uma maioria que não se importa com "essas coisas".

Bem, começamos a conversar, e logo o Ivan e o Raniere deram sinais de que eles topariam participar do grupo, sem problemas. Portanto, o solo já estava fértil para novas idéias :-).

Um dia, eu acordei e vi na minha INBOX uma mensagem do Raniere dizendo que havia encontrado algo sobre um projeto interessante, o LibrePlanet, na Internet. Foi a faísca que faltava pra começar a movimentação! Recordei-me de que eu já havia conversado com o Matt Lee, também da FSF, sobre o LibrePlanet, e depois de uma rápida busca na wiki do projeto, vi que ainda não havia nenhum grupo brasileiro. Então, depois de alguma conversa interna, decidimos criar um grupo para o Estado de São Paulo.

Hoje, pouco mais de 2 semanas depois da criação, contamos com 10 membros cadastrados na Wiki, e aproximadamente 7 membros ativos no nosso canal de IRC. Também temos uma lista de discussão, e já estamos começando a conversar sobre possíveis projetos para 2013.

Como você pode fazer parte do grupo?

É simples! Siga os seguintes passos:

  1. Entre na nossa Wiki, e leia todas as informações presentes lá antes de qualquer coisa!
  2. Depois disso, efetue a criação de seu usuário na FSF, indo até este link de cadastro e preenchendo as informações. Repare que você não precisa tornar-se membro da FSF (os membros são pessoas que contribuem financeiramente com a Fundação), mas se você puder, iria ser bem legal :-).
  3. Ok, agora que você já possui um usuário, efetue o login na Wiki do LibrePlanet, e crie sua página pessoal lá. Para isso, vá até este link, clique no link Edit, e insira algumas informações sobre lá. Se quiser, utilize minha página pessoal como exemplo. É importante que você insira, no final de todo o conteúdo, a seguinte linha: {% raw %}{{user SP}}{% endraw %}. Ele faz com que você passe a pertencer ao grupo LibrePlanet de São Paulo.
  4. Agora, é importante que você também efetue sua inscrição na nossa lista de discussão. Vá até esta página de inscrição e preencha as informações necessárias! Também recomendamos fortemente que você envie uma mensagem de apresentação para a lista. Nada formal, só para termos uma idéia do tamanho do grupo!
  5. Ufa, último passo! Se você utiliza IRC e frequenta a rede Freenode, entre no nosso canal: #lp-br-sp! É lá que a maior parte das discussões acontece, então seria muito legal se você também pudesse participar delas!

Acho que é isso :-). Se você ainda tiver alguma dúvida sobre qualquer assunto tratado neste post (objetivos do grupo, inscrição, etc), ou se quiser fazer algum comentário, sinta-se à vontade!

Saudações livres!


Nesta última sexta-feira, dia 30/11/2012, estive presente na sétima edição do SoLiSC 2012, em Florianópolis, para apresentar uma palestra introdutória sobre o GDB. Este é um relato sobre minha particição no evento :-).

Impressões sobre o evento

Foi a primeira vez que fui ao SoLiSC. Já tive vontade de ir em anos anteriores, mas infelizmente sempre havia algo para atrapalhar. No entanto, nesse ano felizmente tudo correu bem, e inclusive tive uma palestra aceita! Ou seja, um ótimo motivo para visitar Floripa e rever o mar :-D.

Peguei um vôo saindo às 6h de Campinas, e cheguei lá às 7h10min. Estava bastante cansado, pois não havia dormido de quinta pra sexta, só que a ansiedade estava conseguindo me deixar ligado :-).

O evento aconteceu Universidade Estácio de Sá, que fica em São José. Cheguei por lá às 8h, e fui bem recebido pelo pessoal do evento. Já tentei me enturmar, e conheci algumas pessoas que também iam palestrar no evento. Como minha palestra estava marcada para começar às 14h, resolvi ficar batendo papo e de olho na grade de palestras.

Por coincidência (ou não!), acabei ficando na sala onde aconteceria o primeiro LibreOffice Hack Day no Brasil. Acabei ficando na sala o dia todo, ajudando o pessoal a resolver alguns problemas chatos com o firewall da Universidade, e depois com git. Foi uma experiência muito legal, nunca tinha participado de um Hack Day antes, e foi uma honra poder presenciar e ajudar no primeiro evento do tipo que o pessoal do LibreOffice fez no Brasil :-). Aliás, foi muito interessante conhecer um pouco mais sobre um projeto tão grande e complexo quanto o LibreOffice, e inclusive fiz um "jabá" sobre o GDB para eles :-).

No final, também conheci algumas pessoas muito interessadas em contribuir com projetos de software livre, o que é sempre bom! Isso me ajuda a ter mais motivação para continuar a fazer esse trabalho de divulgação. Você pode ler uma descrição mais detalhada sobre o LibreOffice Hack Day (inclusive com fotos) aqui.

Apresentação "GDB Crash Course"

Eu já estava esperando pouca gente na palestra, até porque falar sobre o GDB está ficando cada vez mais complicado... As pessoas em geral não sabem (e nem se interessam) pelo software, então é normal ficar meio "de escanteio" nesses eventos :-). Quem sabe um dia eu não escreva um post sobre isso?

Bem, mas mesmo com pouco público, creio que palestra correu bem. Dessa vez, meu amigo Edjunior não foi, então levei a palestra sozinho :-). Existem vantagens e desvantagens nisso, mas de modo geral acho que a palestra ficou um pouco mais rápida.

Adicionei alguns slides extras para falar sobre a Red Hat, e sobre o que estamos fazendo pelas comunidades de software livre por aí -- não só na do GDB, mas também em muitas outras. Essa parte da apresentação realmente foi bacana, porque o orgulho de se trabalhar nessa empresa é grande!

Depois que terminei minha palestra e voltei à sala do LibreOffice Hack Day, alguns desenvolvedores que estavam por lá me perguntaram como foi, e disseram que tinham se arrependido de não ter ido... Sabe como é, preferiram ficar fazendo patches, então eu entendo :-P. Bem, pra não deixar ninguém insatisfeito, acabei fazendo uma segunda rodada da palestra dentro do Hack Day, e também foi muito bacana :-).

Várias pessoas me pediram os slides, então aqui estão eles:

Conclusão

Gostaria de agradecer especialmente à Eliane Domingos, ao David Jourdain e ao Olivier Hallot, todos membros da TDF e contribuidores do LibreOffice, pelos momentos prazerosos e pelas conversas divertidas que tivemos durante todo o evento!

Também gostaria de agradecer à organização do SoLiSC pela oportunidade de participar de um evento tão bacana! O Klaibson Ribeiro foi a pessoa com quem troquei alguns e-mails antes do evento, então um "muito obrigado" a ele também :-).

Nos vemos no próximo SoLiSC!


Hi there. This little post is just a heads about an issue that I am facing with the comment system that I run. Unfortunately, you will not be able to post comments on the blog until, at least, next Wednesday (November 21).

For those of you wondering which comment system I use, it is called Juvia. Due to privacy concerns, I chose not to use anything like Disqus because it tracks you and your comments (read their privacy policy if you want more details). On the other hand, Juvia runs on my private personal server, and does not collect any kind of personal information when you make a comment. The cons of this approach is that when my personal server is down (like now), the blog doesn't have comments. But that's a minor price to pay for the respect of privacy, I think.

Anyway, I hope to have the comments back online next week. Until there, I plan to continue making posts here, so save your comments for some time!

Thanks!


Hi everybody :-).

I finally got some time to finish this series of posts, and I hope you like the overall result. For those of you who are reading this blog for the first time, you can access the first post here, and the second here.

My goal with this third post is to talk a little bit about how you can use the SDT probes with tracepoints inside GDB. Maybe this particular feature will not be so helpful to you, but I recommend reading the post either way. I will also give a brief explanation about how the SDT probes are laid out inside the binary. So, let's start!

Complementary information

In my last post, I forgot to mention that the SDT probe support present on older versions of Fedora GDB is not exactly as the way I described here. This is because Fedora GDB adopted this feature much earlier than upstream GDB itself, so while this has a great positive aspect in terms of how the distro's philosophy works (i.e., Fedora contains leading-edge features, so if you want to know how to FLOSS community will be in a few months, use it!), it also has the downside of delivering older/different versions of features in older Fedoras. But of course, this SDT feature will be fully available on Fedora 18, to be announced soon.

My suggestion is that if you use a not-so-recent Fedora (like Fedora 16, 15, etc), please upgrade it to the last version, or compile your own version of GDB yourself (it's not that hard, I will make a post about it in the next days/weeks!).

With that said, let's move on to our main topic here.

SDT Probes and Tracepoint

Before anything else, let me explain what a tracepoint is. Think of it as a breakpoint which doesn't stop the program's execution when it hits. In fact, it's a bit more than that: you can define actions associated with a tracepoint, and those actions will be performed when the tracepoint is hit. Neat, huh? :-)

There is a nice description of what a tracepoint in the GDB documentation, I recommend you give it a reading to understand the concept.

Ok, so now we have to learn how to put tracepoints in our code, and how to define actions for them. But before that, let's remember our example program:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include <sys/sdt.h>

int
main (int argc, char *argv[])
{
    int a = 10;

    STAP_PROBE1 (test_program, my_probe, a);

    return 0;
}

Very simple, isn't it? Ok, to the tracepoints now, my friends.

Using tracepoints inside GDB

In order to properly use tracepoints inside GDB, you will need to use gdbserver, a tiny version of GDB suitable for debugging programs remotely, over the net or serial line. In short, this is because GDB cannot put tracepoints on a program running directly under it, so we have to run it inside gdbserver and then connect GDB to it.

Running our program inside gdbserver

In our case, we will just start gdbserver in our machine, order it to listen to some high port, and connect to it through localhost, so there will be no need to have access to another computer or device.

First of all, make sure you have gdbserver installed. If you use Fedora, the package name you will have to install is gdb-gdbserver. If you have it installed, you can do:

1
2
3
$ gdbserver :3001 ./test_program
Process ./test_program created; pid = 17793
Listening on port 3001

The second argument passed to gdbserver instructs it to listen on the port 3001 of your loopback interface, a.k.a. localhost.

You will notice that gdbserver will stay there indefinitely, waiting for new connections to arrive. Don't worry, we will connect to it soon!

Connecting an instance of GDB to gdbserver

Now, go to another terminal and start GDB with our program:

1
2
3
4
5
6
7
$ gdb ./test_program
...
(gdb) target remote :3001
Remote debugging using :3001
Reading symbols from /lib64/ld-linux-x86-64.so.2...(no debugging symbols found)...done.
Loaded symbols for /lib64/ld-linux-x86-64.so.2
0x0000003d60401530 in _start () from /lib64/ld-linux-x86-64.so.2

The command you have to use inside GDB is target remote. It takes as an argument the host and the port to which you want to connect. In our case, we just want it to connect to localhost, port 3001. If you saw an output like the above, great, things are working for you (don't pay attention to the messages about glibc debug information). If you didn't see it, please check to see if you're connecting to the right port, and if no other service is using it.

Ok, so now it is time to start our trace experiment!

Creating the tracepoints

Every command should be issued on GDB, not on gdbserver!

In your GDB prompt, put a tracepoint in the probe named my_probe:

1
2
(gdb) trace -probe-stap my_probe
Tracepoint 1 at 0x4005a9

As you can see, the trace command takes exactly the same arguments as the break command. Thus, you need to use the -probe-stap modified in order to instruct GDB to put the tracepoint in the probe.

And now, let's define the actions associated with this tracepoint. To do that, we use the actions command, which is an interactive command inside GDB. It takes some specific keywords, and if you want to learn more about it, please take a look at this link. For this example, we will use only the collect keyword, which tells GDB to... hm... collect something :-). In our case, it will collect the probe's first argument, or $_probe_arg0, as you may remember.

1
2
3
4
5
6
(gdb) actions 
Enter actions for tracepoint 1, one per line.
End with a line saying just "end".
>collect $_probe_arg0
>end
(gdb)

Simple as that. Finally, we have to define a breakpoint in the last instruction of our program, because it is necessary to keep it running on gdbserver in order to examine the tracepoints later. If we didn't put this breakpoint, our program would finish and gdbserver would not be able to provide information about what happened with our tracepoints. In our case, we will simply put a breakpoint on line 10, i.e., on the return 0;:

Running the trace experiment

Ok, time to run our trace experiment. First, we must issue a tstart to tell GDB to start monitoring the tracepoints. And then, we can continue our program normally.

1
2
3
4
5
6
7
8
(gdb) tstart 
(gdb) continue
Continuing.

Breakpoint 1, main (argc=1, argv=0x7fffffffde88) at /tmp/test_program.c:10
10        return 0;
(gdb) tstop
(gdb)

Remember, GDB is not going to stop your program, because tracepoints are designed to not interfere with the execution of it. Also notice that we have also stopped the trace experiment after the breakpoint hit, by using the tstop command.

Now, we will be able to examine what the tracepoint has collected. First, we will the tfind command to make sure the tracepoint has hit, and then we can inspect what we ordered it to collect:

1
2
3
4
5
(gdb) tfind start
Found trace frame 0, tracepoint 1
8         STAP_PROBE1 (test_program, my_probe, a);
(gdb) p $_probe_arg0
$1 = 10

And it works! Notice that we are printing the probe argument using the same notation as with breakpoints, even though we are not exactly executing the STAP_PROBE1 instruction. What does it mean? Well, with the tfind start command we tell GDB to actually use the trace frame collected during the program's execution, which, in this case, is the probe argument. If you know GDB, think of it as if we were using the frame command to jump back to a specific frame, where we would have access to its state.

This is a very simple example of how to use the SDT probe support in GDB with tracepoints. There is much more you can do, but I hope I could explain the basics so that you can start playing with this feature.

How the SDT probe is laid out in the binary

You might be interested in learning how the probes are created inside the binary. Other than reading the source code of /usr/include/sys/sdt.h, which is the heart of the whole feature, I also recommend this page, which explains in detail what's going on under the hood. I also recommend that you study a little about how the ELF format works, specifically about notes in the ELF file.

Conclusion

After this series of blog posts, I expect that you will now be able to use the not-so-new feature of SDT probe support on GDB. Of course, if you find some bug while using this, please feel free to report it using our bugzilla. And if you have some question, use the comment system below and I will answer ASAP :-).

See ya, and thanks for reading!


In the last days, there was some fuzz about Mark Shuttleworth's post about some news in Ubuntu. Well, to be more precise, the post was about some secrets regarding the development of some applications. In my opinion, it summarizes some of what this distribution has become, and I would like to talk a little bit about it here.

My goal is not say bad things about Ubuntu (though I won't promise that, because the post is intended as a critic), nor about Mr. Shuttleworth, whom I don't know personally and have nothing against. My purpose is to discuss what we can learn from this surprising movement (at least for me) from a distribution (and a company, of course), and what mistakes they are doing by keeping some things for their own until they decide to unveil, as Mark said in his post.

Canonical and Ubuntu are both drifting away from the free software (or even from the open source) movement, and they are doing this by adopting some ugly tactics like the one mentioned above. Free software is a win-win game only if you respect its first rule: freedom. This word has infinite meanings, but for FLOSS there are 4 basic rules (or freedoms) that should be obeyed:

  1. The freedom to run the program, for any purpose (freedom 0).
  2. The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1). Access to the source code is a precondition for this.
  3. The freedom to redistribute copies so you can help your neighbor (freedom 2).
  4. The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.

I won't be polemical and say that Ubuntu is not obeying some of these rules (though I could...). But it should be obvious that, by developing something in secrecy, you are not respecting one's freedom to decide which way they think the software should behave (or not behave). In a true free software community everyone can have a voice (though sometimes people refuse to hear it, but that's another problem which I'll probably talk about in another post); everyone can help making a decision, or can try to influence some bad design choice (in his/her opinion). To summarize, they can participate.

As much as I don't like the way Ubuntu hardly gives something back to the communities (if you compare to what they take from them), at least their development model (or at least what I know from it) so far was open. Every company has its sensible topics that need to be discussed internally. Even Red Hat, the company I work for (and now maybe you think this post is totally biased...), does. But you should keep it to the really minimum, and really discuss things in the open whenever you can. And you should never do software development like the not-so-old-but-still-obscure days: locked in your room, without external contact and feedback, trying to guess what your users want, and still holding the freedom flag sometimes. Sorry, but this is non-sense.


I tell you this: it is depressing when you realize that you spent more time struggling with blog engines than writing posts on your blog!

It's been a long time since I wrote the first post about this subject, and since then the patches have been accepted upstream, and GDB 7.5 now has official support for userspace SystemTap probes :-). Yay!

Well, but enough of cheap talk, let's get to the business!

Errata for my last post

Frank Ch. Eigler, one of SystemTap's maintainers, kindly mentioned something that I should say about SystemTap userspace probes.

Basically, it should be clear that SDT probes are not the only kind of userspace probing one can do with SystemTap. There is yet another kind of probe (maybe even more powerful, depending on the goals): DWARF-based function/statement probes. SystemTap supports this kind of probing mechanism for quite a while now.

It is not the goal of this post to explain it in detail, but you might want to give it a try by compiling your binary with debuginfo support (use the -g flag on GCC), and do something like:

1
2
$ stap -e 'probe process("/bin/foo").function("name") { log($$parms) }' -c /bin/foo
$ stap -e 'probe process("/bin/foo").statement("*@file.c:443") { log($$vars) }' -c /bin/foo

And that's it. You can read SystemTap's documentation, or this guide to learn how to add userspace probes.

Using GDB with SystemTap SDT Probes

Well, now let's get to the interesting part. It is time to make GDB work with the SDT probe that we have put in our example code. Let's remember it:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include <sys/sdt.h>

int
main (int argc, char *argv[])
{
  int a = 10;

  STAP_PROBE1 (test_program, my_probe, a);

  return 0;
}

It is a very simple example, and we will have to extend it later in order to show more features. But for now, it will do.

The first thing to do is to open GDB (with SystemTap support, of course!), and check to see if it can actually see probe inserted in our example.

1
2
3
4
5
6
7
8
$ gdb ./test_program
GNU gdb (GDB) 7.5.50.20121014-cvs
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
...
(gdb) info probes
Provider     Name     Where              Semaphore Object
test_program my_probe 0x00000000004004ae           /home/sergio/work/src/git/build/gdb/test_program

Wow, it actually works! :-)

If you have seen something like the above, it means your GDB is correctly recognizing SDT probes. If you see an error, or if your GDB doesn't have the info probes command, then you'd better make sure you have a recent version of GDB otherwise you won't be able to use the SDT support.

Putting breakpoints in the code

Anyway, now it is time to start using this support. The first thing I want to show you is how to put a breakpoint in a probe.

1
2
(gdb) break -probe-stap my_probe
Breakpoint 1 at 0x4004ae

That's all! We have chosen to extend the break command in order to support the new -probe-stap parameter. If you're wondering ... why the -probe prefix?, it is because I was asked to implement a complete abstraction layer inside GDB in order to allow more types of probes to be added in the future. So, for example, if someone implements support for an hypothetical type of probe called xyz, you would have break -probe-xyz. It took me a little more time to implement this layer, but it is worth the effort.

Anyway, as you have see above, GDB recognize the probe's name and correctly put a breakpoint in it. You can also confirm that it has done the right thing by matching the address reported by info probes with the one reported by break: they should be the same.

Ok, so now, with our breakpoint in place, let's run the program and see what happens.

1
2
3
4
5
(gdb) run
Starting program: /home/sergio/work/src/git/build/gdb/test_program

Breakpoint 1, main (argc=1, argv=0x7fffffffdf68) at /tmp/example-stap.c:8
8  STAP_PROBE1 (test_program, my_probe, a);

As you can see, GDB stopped at the exact location of the probe. Therefore, you are now able to put marks (i.e., probes) in your source code which are location-independent. It means that it doesn't really matter where in the source code your probe is, and it also doesn't matter if you change the code around it, changing the line numbers, or even moving it to another file. GDB will always find your probe, and always stop at the right location. Neat!

Examining probes' arguments

But wait, there's more! Remember when I told you that you could also inspect the probe's arguments? Yes, let's do it now!

Just remember that, in SDT's parlance, the current probe's argument is a. So let's print its value.

1
2
3
4
(gdb) p $_probe_arg0
$1 = 10
(gdb) p a
$2 = 10

"Hey, captain, it seems the boat really floats!"

Check the source code above, and convince yourself that a's value is 10 :-). As you might have seen, I have used a fairly strange way of printing it. It is because the probe's arguments are available inside GDB by means of convenience variables. You can see a list of them here.

Since SDT probes can have up to 12 arguments (i.e., you can use STAP_PROBE1 ... STAP_PROBE12), we have created inside GDB 12 convenience variables, named $_probe_arg0 until $_probe_arg11. I know, it is not an easy name to remember, and even the relation between SDT naming and GDB naming is not direct (i.e., you have to subtract 1 from the SDT probe number). If you are not satisfied with this, please open a bug in our bugzilla and I promise we will discuss other options.

I would like to emphasize something here: just as you don't need debuginfo support for dealing with probes inside GDB, you also don't need debuginfo support for dealing with their arguments as well. It means that you can actually compile your code without debuginfo support, but still have access to some important variables/expressions when debugging it. Depending on how GCC optimizes your code, you may experience some difficulties with argument printing, but so far I haven't heard of anything like that.

More to come

Ok, now we have covered more things about the SDT probe support inside GDB, and I hope you understood all the concepts. It is not hard to get things going with this, specially because you don't need extra libraries to make it work.

In the next post, I intend to finish this series by explaining how to use tracepoints with SDT probes. Also, as I said in the previous post of this series, maybe I will talk a little bit about how the SDT probes are organized within the binary.

See you soon!


Conforme eu havia comentado no post anterior, segue o relato sobre as apresentações que fiz na Semana da Computação da UNESP de Rio Claro.

TL;DR: Gostei de ter tido a oportunidade de dar as apresentações, e principalmente de ter feito minha primeira palestra como Embaixador do Projeto Fedora no Brasil. Sobre a palestra a respeito do GDB, também gostei do jeito que ela foi conduzida. Notei algumas falhas que precisam ser corrigidas, mas no geral a experiência foi muito boa.

Apresentação "O Projeto Fedora"

Foi a primeira apresentação da noite, de acordo com a grade de programação. Começou meia hora atrasada, pois a organização pediu para esperarmos mais pessoas chegarem (estava chovendo bastante no momento, o que dificultou a locomoção).

Comecei a palestra falando um pouco sobre o Projeto Fedora. Acabei passando rapidamente pelas origens do projeto, uma falha que pretendo corrigir em próximas ocasiões. Dei muita ênfase na definição de comunidade e no que isso significa quando lidamos com software livre. Confesso que fiz algumas comparações com o Ubuntu, o que talvez não tenha sido uma boa idéia (de acordo com os guidelines do Projeto Fedora para Embaixadores). De qualquer modo, a mensagem foi passada e notei que algumas pessoas se interessaram em conhecer mais a respeito do projeto e da filosofia.

Pontos positivos: Creio ter conseguido informar as pessoas a respeito do projeto, com a ajuda dos ótimos slides do Paul W. Frields. É sempre gratificante dar palestras, mesmo que apenas uma ou duas pessoas no final acabem se interessando de verdade. Além disso, me senti bem por estar divulgando um projeto que respeita as liberdades dos usuários (ou pelo menos tenta fazer isso ao máximo), e que eu realmente uso e gosto.

Pontos a serem melhorados: Fazer uma palestra um pouco menos "pessoal". É muito difícil conseguir isso, mas tenho a forte impressão de que minha orientação totalmente pró-software-livre acaba (às vezes) afastando algumas pessoas, que vêem no entusiasta por software livre uma pessoa "radical" e "xiita". Preciso pensar um pouco a respeito do assunto...

A conclusão é que fiquei bastante satisfeito com o resultado da palestra. Percebi que, depois dela, algumas pessoas vieram comentar que estavam utilizando Fedora, ou que já andavam pensando em trocar de distribuição, que agora o Fedora era uma opção. O objetivo foi cumprido :-).

Apresentação "GDB Crash Course"

Creio que essa já é a quarta vez que apresento essa palestra, e a terceira vez junto com meu amigo Edjunior. Sempre que ela termina, fico(amos) com a impressão de que ainda não acertamos no ponto, e dessa vez não foi diferente.

A palestra começou em ponto, às 21h, e decidimos tentar uma abordagem um pouco diferente. A última vez que apresentamos a palestra foi no evento da Semana Integrada da PUC Campinas. Naquela ocasião, tínhamos optado por começar falando mais sobre os comandos do GDB, e depois mostrarmos como a coisa funciona, estilo hands-on. Dessa vez, resolvemos ir mostrando a prática junto com a teoria. Ficou melhor, e acho que a apresentação ficou mais fluida, mas ainda assim esbarramos no velho problema da interdependência dos comandos: quando íamos falar sobre breakpoints, precisávamos ter mostrado algum outro comando que só iria ser explicado mais à frente, que por sua vez iria precisar de outro comando, que iria precisar de breakpoints, etc. Enfim, no final acabamos sendo obrigados a pular alguns comandos, e a adiantar a explicação de outros, quebrando um pouco o fluxo dos slides.

Notei que algumas pessoas estavam bastante interessadas no GDB, talvez por já programarem há algum tempo. As outras, aparentemente, ainda não conseguiam ver muita utilidade para um depurador, mas mesmo assim tentavam aprender algo que talvez fosse lhes servir no futuro.

Já era de se esperar, mas mesmo assim não deixo de me surpreender quando vejo que uma palestra técnica consegue atrair muito mais atenção do que uma palestra "filosófica", como foi a do Projeto Fedora. Talvez seja reflexo da sociedade em que vivemos, ou talvez seja apenas uma impressão errônea da minha parte.

A conclusão, finalmente, é que a palestra parece ter sido útil para algumas pessoas (mesmo que poucas), e isso nos dá ainda mais fôlego pra continuarmos tentando divulgar esse projeto pouco conhecido (mas muito útil) que é o GDB.

Agradecimentos

Não poderia deixar de agradecer primeiramente à organização da SECCOMP da UNESP de Rio Claro pelo ótimo evento. Fiquei surpreso com a infra-estrutura e, principalmente, com a receptividade das pessoas. Gostei muito do ambiente descontraído, e espero não ter decepcionado muita gente por lá com meus comentários informais e caipiras durante as palestras :-).

Também agradeço ao meu amigo Edjunior por ter me acompanhado até sua alma matter para me ajudar na realização da palestra sobre o GDB.

Até a próxima!