Feeds:
Posts
Comments

If you use Rythmbox and you hate the way some plugins for music lyrics works and  are broken briging just piece of the lyric and not the whole one. Well, I just suggest you to use my plugin that uses AZLyric instead terra.com. AZlyric web site is,  for me, the best source of indie lyrics/bands/musics you can find :).

If you want to try, feel free trying my beautiful plugin :3 https://github.com/kirotawa/pluginsinpython/tree/master/rhythmbox/patches_rhythm_git. If you find some bug, please report me :). I’m already using this patch on my rythmbox. Unfortunatelly no one in rythm devel list seemed be interested in such thing. But well, I’m using, I’m taking advantage on this, and I’m happy :P.

Desenvolver software em C requer muita atenção, mas às vezes deixamos alguns descuidos. Em C um descuido pode ser grave, pode gerar bugs indesejados (não que haja algum desejado). Um dos erros comuns é não lidar corretamente com a alocação de recurso de memória. Em particular, alocar e esquecer de liberar ela para o sistema (memory leak).

Ao contrário de linguagens como Java, Python, C++ que possuem garbage collector, C é uma linguagem que espera de você a sabedoria de um Jedi na hora de lidar com recursos de baixo nível, tal como memória.

Quando um problema de memory leak acontece em user space (aplicações a nível de usuário)  a solução é partir para ferramentas bem conhecidas como Valgrind. Com ela é possível encontrar informações precisas sobre os memory leaks causados. Mas e se você programa em nível de Kernel, um driver/modulo por exemplo? Bem, o ponto é que você deve ser um mestre Jedi se chegou a esse nível e memory leaks não deveriam ser erros comuns no seu dia a dia. Mas somos humanos, certo?

Kmemleak foi introduzido no kernel 2.6.17-rc6. É nada mais que um mecanismo de memleak detector em kernel space. Tem lá o seu custo, já que a ideia por trás do kmemleak é varrer de tempos em tempos o kernel, descobrir quais memorias estão/foram alocadas e quais não foram liberadas, dessa forma sinalizando ou possíveis memleaks ou de fato um. 

Há uma discussão extensa sobre esse recurso. Se ele é realmente útil, se o custo dele não é um peso para quem quer usar. Principalmente em sistemas com muito recurso de memoria. Não por menos, quando se usa o kmemleak se percebe um certo acréscimo de tempo no boot do sistema.

Porém, considerações de lado, vamos imaginar que em algum momento você precisará usar este recurso. Então, como usá-lo?

Antes de tudo você irá precisar compilar o seu kernel com esse recurso selecionado  CONFIG_DEBUG_KMEMLEAK (kernel hacking -> kernel memory leak detector). Segundo, você irá precisar setar o tamanho do log que o kmemleak irá usar. O valor default é 400, aconselho usar o limite: 40000 assim você irá evitar surpresas (o recurso estourar o log e ficar desabilitado).

Com o kernel compilado com as opções de kmemleak é só instalar e rebootar a máquina. Feito isso partimos para a montagem do debugfs, pois é lá que o sysfs para o kmemleak estará presente para ser usado.  Para tal: mount -t debugfs nodev /sys/kernel/debug/.  Pronto, seu kmemleak detector está pronto para ser usado.

Como usá-lo:

  • echo clear > /sys/kernel/debug/kmemleak (limpa o log atual e talvez você queira fazer isso antes de buscar pelos leaks do seu módulo)
  • echo scan > /sys/kernel/debug/kmemleak (força um scan nesse instante, uma vez que por default o scan é realizado de 10 em 10 minutos. Este é o valor default e você poderá alterá-lo)
  • cat /sys/kernel/debug/kmemleak (irá listar os possíveis memory leaks encontrados)

Para saber mais sobre como usar o kmemleak dê uma olhada na documentação link [1]

Para testar como ele funciona você pode escrever um simples módulo hello world e provocar um memory leak.

  #include <linux/kernel.h>                                                                                                                                                                                                       
  #include <linux/module.h>
  #include <linux/init.h>
  #include <linux/vmalloc.h>

  void causing_memleak(void)
  {
          char *ptr;
          ptr = vmalloc(1024);
  }

  static int __init hello_init(void)
  {
          causing_memleak();
          pr_debug(KERN_DEBUG "Hello World!\n");
          return 0;
  }
  
  static void hello_cleanup(void)
  {
          pr_debug(KERN_DEBUG "Cleaning up\n");
  }
  
  module_init(hello_init);
  module_exit(hello_cleanup);

No código acima a função “causing_memleak” aloca um dado recurso de memória, mas nunca o libera. Se você carregar este módulo e depois liberar ele, por fim usar kmemleak: cat /sys/kernel/debug/kmemleak, você verá que ele foi detectado.

Finalizando, é um recurso útil, mas o mais esperado é que você saiba o que tá fazendo e que jamais deixe que situações como esta ocorra em kernel space :). Mas se um dia precisar usar kmemleak, go ahead.

Referências:
[1] https://www.kernel.org/doc/Documentation/kmemleak.txt

[2] http://lwn.net/Articles/187193/

[3] http://psankar.blogspot.com.br/2010/11/detecting-memory-leaks-in-kernel.html

[4]  https://lwn.net/Articles/187979/

Você que está brincando com o eudpytula, essa é pra você.

  • Compila: make localmodconfig (assim ele vai selecionar os módulos que realmente importam para sua distro)
  • yes “” | make localmodconfig (dê yes pra todo mundo)
  • make -j42 (substitua 42 pelo seu número de cores, ou deixe o 42 e ele usará o máximo)
  • make modules (construindo seus módulos)
  • make modules_install
  • make install
  • Reboot, teste, chore se o seu kernel bugar.
  • Hora da limpeza, você terá que deletar do /boot, na mão, o que você não quer. Depois, grub-mkconfig -o <<caminho do grub.cfc).

 

Done =)

Para aqueles que começaram a programar em Python agora, encontrar regras de indentação, e mais importante, quebrar elas e receber erros no shell, não deve ser algo muito interessante.
Eu particularmente gosto das regras do Python, elas agregam valor as boas práticas de coding. Tudo para que seu código seja mais legível e outros possam lê-lo um dia, em um futuro, sem precisar te xingar.

Como auxílio as boas práticas é possível encontrar alguns cheats e ferramentes que podem ajudar.
Primeiro, os cheats (e infelizmente essa é apenas para usuários vim/vi).

  • Nada mais que 80 colunas: essa ideia não poderia ser melhor, já que nem todo mundo usa um monitor wide screen, certo. Basta por essa linha no seu .vimrc silent match ErrorMsg /\%>80v/
  • 4 espaços: essa vem direto do PEP08. Diferente do Kernel que usa 8 espaços ou GNU style. Python usa 4 espaços (nada de tab!). Basta setar as seguintes linha no seu .vimrc e tudo funcionará perfeitamente.
set smartindent
set tabstop=4
set softtabstop=4
set shiftwidth=4
set expandtab
  • Retab: útil se o seu arquivo está zoneado por tabs. Basta digitar ESC: %retab no vim. Ele vai arrumar seu .py de acordo com a configuração anterior de espaços.
  • Removendo espaços no final da linha ou traling white spaces: autocmd BufWritePre *.py :%s/\s\+$//e.

Bacana, certo?

Para auxiliar ainda mais, que tal usar uma ferramenta chamada pep8 que vai te ajudar a checar se o seu arquivo está de acordo com o pep08 e de quebra usar o Pylint para analisar estaticamente o seu código?

Ambas são incrivelmente fáceis de se usar. Então, espero que essas dicas tenham sido úteis =)

Essas mensagens apareceram para mim quando pensei em atualizar o gtalk para hangout. Para bom entendedor o que o texto diz está mais do que claro. A finalidade no entanto pode ser interpretada como você bem quiser. Pra mim, o Google deixou a muito de ser uma empresa inovadora e passou a ser uma empresa de propagandas. Não por menos, afinal é assim que eles fazem os seus milhões.

Não venda sua liberdade.

 

image

 

image

Dica simples e rápida para quem costuma usar sites de cotação de passagens para comprá-las.

  1. Primeiro abra uma aba para o site de cotação. 
  2. Faça a cotação e salve o preço 
  3. Agora abra um outro browser (de preferência outro mesmo), só que dessa vez em modo privativo (aquele modo que você usa pra coisas escusas).
  4. Abra o site que você usa para cotar as passagens e faça uma nova cotação para o mesmo trajeto e período. Veja a diferença.

Aqui eu fiz um teste e tive 2.900k pra um destino X e em modo privativo obtive 2.500k para o mesmo destino dentro de um mesmo período. 
Sim senhoras e senhores, todos os sites de compra e cotação de passagens aéreas fazem isso. Eu já havia percebido isso, você provavelmente também. O grande problema é que não é ilegal, mas que é uma safadeza é. 

Espero que a dica sirva para vocês, pra mim esta servindo.

OBS: Por razões óbvias eu não postei nenhuma imagem de sites de cotação – não quero ser processado. Por isso, vejam vocês mesmo, afinal é bem simples.

 

I finally diced post something about that monsters…

You know, EFI/UEFI is the new magical stuffs that one day visa replace the BIOS and do nice things in UEFI mode, no more legacy. Maybe you already had heard something about that, mainly that new Win8 and Security Boot.

But, let’s talk a little about EFI, a truly little, :P.

These days I need to play with EFI in Linux and  dude it was not a nice thing. First because the material about how to play with EFI/UEFI and linux is poor or almost impossible to find out there in web. Yep, I found of lot specs by Intel talking about EFI and UEFI specs , ok. But I really wanted to find more material, more practical material.

So, just let talk about my Study of Case. In my Kernel I’m trying to grab a physical address that is an EFI_MEMORY_RUNTIME range. It’s means that it needs to be mapped in runtime. This address or efi runtime service neither a boot service, and here the things becomes a little bit trick and complicated. The biggest problem is that I need to run that physical address since it is an address to a function in EFI space, but into that function I  have some mysterious access to another physical address, what makes me unable to map that address to a virtual and use it nice and clean.  (I already did it and fall in a unable access page)

Now I really need to run it in physical space using some EFI trick, but is also now that my Odyssey starts. In any place in web I could found any good material or any little example of how to do that. Ok, that I’m trying to do is insane and maybe impossible or a nice party hard.

In EFI we/I found that efi_phy_prelog (thanks some god, in linux we have a little bit of efi files), that seems allow that a piece of physical code/address can run between it and efi_phys_epilog. But of course that does not work for me in my tests =).

The problem: Run a physical function/physical address into the kernel space in physical mode using some trick EFI or other else magical thing.

Solution: Try to put the whole map to this function in kernel table, when I say whole I really want to say that, include that physical address that is into the black box function.

Hope solution: EFI could me drive to this physical mode and run my code without all theses tricks and painful things.

Frustration: none in linux-efi list could help me/us in that adventure time through EFI and linux experience.

If you want to know more about EFI/UEFI take a look in that and be happy or cry.

If you already play with something like that =) feel free to give me clues, tips, any thing!

P.S: Sorry for my bad English, it is still being improved.

[1] http://wiki.phoenix.com/wiki/index.php/EFI_SYSTEM_TABLE

[2] http://www.intel.com/content/www/us/en/architecture-and-technology/unified-extensible-firmware-interface/efi-homepage-general-technology.html

Follow

Get every new post delivered to your Inbox.